xmos-ai-tools 1.3.2.dev80__py3-none-macosx_10_15_universal2.whl

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

@@ -0,0 +1,62 @@
+/* Copyright 2020 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_OP_RESOLVER_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_OP_RESOLVER_H_
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_common.h"
+#include "tensorflow/lite/micro/tflite_bridge/flatbuffer_conversions_bridge.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+namespace tflite_micro {
+
+// This is an interface for the OpResolver for TFLiteMicro. The differences from
+// the TFLite OpResolver base class are to:
+//  * explicitly remove support for Op versions
+//  * allow for finer grained registration of the Builtin Ops to reduce code
+//    size for TFLiteMicro.
+//
+// We need an interface class instead of directly using MicroMutableOpResolver
+// because MicroMutableOpResolver is a class template with the number of
+// registered Ops as the template parameter.
+class MicroOpResolver {
+ public:
+  // Returns the Op registration struct corresponding to the enum code from the
+  // flatbuffer schema. Returns nullptr if the op is not found or if op ==
+  // BuiltinOperator_CUSTOM.
+  virtual const TFLMRegistration* FindOp(BuiltinOperator op) const = 0;
+
+  // Returns the Op registration struct corresponding to the custom operator by
+  // name.
+  virtual const TFLMRegistration* FindOp(const char* op) const = 0;
+
+  // Returns the operator specific parsing function for the OpData for a
+  // BuiltinOperator (if registered), else nullptr.
+  virtual TfLiteBridgeBuiltinParseFunction GetOpDataParser(
+      BuiltinOperator op) const = 0;
+
+  virtual ~MicroOpResolver() {}
+};
+
+// Handles the logic for converting between an OperatorCode structure extracted
+// from a flatbuffer and information about a registered operator
+// implementation.
+TfLiteStatus GetRegistrationFromOpCode(const OperatorCode* opcode,
+                                       const MicroOpResolver& op_resolver,
+                                       const TFLMRegistration** registration);
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_OP_RESOLVER_H_

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

@@ -0,0 +1,140 @@
+/* Copyright 2022 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_PROFILER_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_PROFILER_H_
+
+#include "tensorflow/lite/micro/compatibility.h"
+#include "tensorflow/lite/micro/micro_profiler_interface.h"
+
+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
+// sections. This can be used in conjunction with running the relevant micro
+// benchmark to evaluate end-to-end performance.
+class MicroProfiler : public MicroProfilerInterface {
+ public:
+  MicroProfiler() = default;
+  virtual ~MicroProfiler() = default;
+
+  // Marks the start of a new event and returns an event handle that can be used
+  // to mark the end of the event via EndEvent. The lifetime of the tag
+  // parameter must exceed that of the MicroProfiler.
+  virtual uint32_t BeginEvent(const char* tag) override;
+
+  // Marks the end of an event associated with event_handle. It is the
+  // responsibility of the caller to ensure than EndEvent is called once and
+  // only once per event_handle.
+  //
+  // If EndEvent is called more than once for the same event_handle, the last
+  // call will be used as the end of event marker.If EndEvent is called 0 times
+  // for a particular event_handle, the duration of that event will be 0 ticks.
+  virtual void EndEvent(uint32_t event_handle) override;
+
+  // Clears all the events that have been currently profiled.
+  void ClearEvents() { num_events_ = 0; }
+
+  // Returns the sum of the ticks taken across all the events. This number
+  // is only meaningful if all of the events are disjoint (the end time of
+  // event[i] <= start time of event[i+1]).
+  uint32_t GetTotalTicks() const;
+
+  // Prints the profiling information of each of the events in human readable
+  // form.
+  void Log() const;
+
+  // Prints the profiling information of each of the events in CSV (Comma
+  // Separated Value) form.
+  void LogCsv() const;
+
+  // Prints  total ticks for each unique tag in CSV format.
+  // Output will have one row for each unique tag along with the
+  // total ticks summed across all events with that particular tag.
+  void LogTicksPerTagCsv();
+
+ private:
+  // Maximum number of events that this class can keep track of. If we call
+  // AddEvent more than kMaxEvents number of times, then the oldest event's
+  // profiling information will be overwritten.
+  static constexpr int kMaxEvents = 4096;
+
+  const char* tags_[kMaxEvents];
+  uint32_t start_ticks_[kMaxEvents];
+  uint32_t end_ticks_[kMaxEvents];
+  int num_events_ = 0;
+
+  struct TicksPerTag {
+    const char* tag;
+    uint32_t ticks;
+  };
+  // In practice, the number of tags will be much lower than the number of
+  // events. But it is theoretically possible that each event to be unique and
+  // hence we allow total_ticks_per_tag to have kMaxEvents entries.
+  TicksPerTag total_ticks_per_tag[kMaxEvents] = {};
+
+  int FindExistingOrNextPosition(const char* tag_name);
+
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+#if defined(TF_LITE_STRIP_ERROR_STRINGS)
+// For release builds, the ScopedMicroProfiler is a noop.
+//
+// This is done because the ScipedProfiler is used as part of the
+// MicroInterpreter and we want to ensure zero overhead for the release builds.
+class ScopedMicroProfiler {
+ public:
+  explicit ScopedMicroProfiler(const char* tag,
+                               MicroProfilerInterface* profiler) {}
+};
+
+#else
+
+// This class can be used to add events to a MicroProfiler object that span the
+// lifetime of the ScopedMicroProfiler object.
+// Usage example:
+//
+// MicroProfiler profiler();
+// ...
+// {
+//   ScopedMicroProfiler scoped_profiler("custom_tag", profiler);
+//   work_to_profile();
+// }
+class ScopedMicroProfiler {
+ public:
+  explicit ScopedMicroProfiler(const char* tag,
+                               MicroProfilerInterface* profiler)
+      : profiler_(profiler) {
+    if (profiler_ != nullptr) {
+      event_handle_ = profiler_->BeginEvent(tag);
+    }
+  }
+
+  ~ScopedMicroProfiler() {
+    if (profiler_ != nullptr) {
+      profiler_->EndEvent(event_handle_);
+    }
+  }
+
+ private:
+  uint32_t event_handle_ = 0;
+  MicroProfilerInterface* profiler_ = nullptr;
+};
+#endif  // !defined(TF_LITE_STRIP_ERROR_STRINGS)
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_PROFILER_H_

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

@@ -0,0 +1,38 @@
+/* Copyright 2022 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_PROFILER_INTERFACE_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_PROFILER_INTERFACE_H_
+
+#include <cstdint>
+
+namespace tflite_micro {
+
+// Interface class that the TFLM framework relies on for profiling.
+class MicroProfilerInterface {
+ public:
+  virtual ~MicroProfilerInterface() {}
+
+  // Marks the start of a new event and returns an event handle that can be used
+  // to mark the end of the event via EndEvent.
+  virtual uint32_t BeginEvent(const char* tag) = 0;
+
+  // Marks the end of an event associated with event_handle.
+  virtual void EndEvent(uint32_t event_handle) = 0;
+};
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_PROFILER_INTERFACE_H_

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

@@ -0,0 +1,89 @@
+/* Copyright 2021 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 TFLITE_MICRO_TENSORFLOW_LITE_MICRO_MICRO_RESOURCE_H_
+#define TFLITE_MICRO_TENSORFLOW_LITE_MICRO_MICRO_RESOURCE_H_
+
+#include <cstdint>
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+
+namespace tflite_micro {
+
+class MicroResourceVariables {
+ public:
+  // Create
+  static MicroResourceVariables* Create(MicroAllocator* allocator,
+                                        int num_variables);
+
+  // Creates a resource variable if none is available for the given container
+  // and shared name pair. Returns the resource ID corresponding to the
+  // container and shared name pair. If allocation fails, the returned resource
+  // ID will be negative. The the container and shared_name must outlive this
+  // class.
+  int CreateIdIfNoneFound(const char* container, const char* shared_name);
+
+  // Read the resource buffer associated with the given ID into the given
+  // tensor.
+  TfLiteStatus Read(int id, const TfLiteEvalTensor* tensor);
+
+  // Allocates the resource buffer if none has been allocated, based on the
+  // length of the input tensor. Copies input tensor contents to the resource
+  // buffer.
+  TfLiteStatus Allocate(int id, TfLiteContext* context,
+                        const TfLiteTensor* tensor);
+
+  // Copies input tensor contents to the resource buffer.
+  // AllocateResourceVariable with a TFLite tensor must have been called first
+  // in order to allocate the resource buffer.
+  TfLiteStatus Assign(int id, const TfLiteEvalTensor* tensor);
+
+  // Zeros out all resource buffers.
+  TfLiteStatus ResetAll();
+
+ private:
+  int FindId(const char* container, const char* shared_name);
+
+  // Micro resource contains the mapping between resource container/name strings
+  // and resouce IDs. Each resource ID corresponds to a resource buffer pointer.
+  // The resouce ID is created during the VAR_HANDLE operator preparation stage.
+  // The resource buffer pointer is created during ASSIGN_VARIABLE preparation
+  // stage based on the size of the TFLiteTensor being assigned.
+  struct MicroResourceVariable {
+    const char* container;
+    const char* shared_name;
+    void* resource_buffer;
+
+    // This is only for verifying read size.
+    size_t bytes;
+    // Initialization default value
+    int8_t default_value;
+  };
+
+  MicroResourceVariables(MicroResourceVariable* variables,
+                         int max_variable_count)
+      : resource_variables_(variables),
+        max_variable_count_(max_variable_count),
+        num_resource_variables_(0) {}
+
+  MicroResourceVariable* resource_variables_;
+  int max_variable_count_;
+  int num_resource_variables_;
+};
+
+}  // namespace tflite_micro
+
+#endif  // TFLITE_MICRO_TENSORFLOW_LITE_MICRO_MICRO_RESOURCE_H_

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

@@ -0,0 +1,36 @@
+/* Copyright 2020 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_TIME_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_TIME_H_
+
+#include <cstdint>
+
+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.
+uint32_t ticks_per_second();
+
+// Return time in ticks.  The meaning of a tick varies per platform.
+uint32_t GetCurrentTimeTicks();
+
+inline uint32_t TicksToMs(int32_t ticks) {
+  return static_cast<uint32_t>(1000.0f * static_cast<float>(ticks) /
+                               static_cast<float>(ticks_per_second()));
+}
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_TIME_H_

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

@@ -0,0 +1,162 @@
+/* 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 <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+
+#include "tensorflow/lite/c/common.h"
+
+namespace tflite_micro {
+
+// Returns number of elements in the shape array.
+
+int ElementCount(const TfLiteIntArray& dims);
+
+size_t EvalTensorBytes(const TfLiteEvalTensor* tensor);
+
+// C++11 does not support constexpr max; hence, use ternary conditional to
+// create our own constexpr Max function.
+constexpr int Max(int a, int b) { return a >= b ? a : b; }
+
+// Converts a float value into a quantized value.  Note that large values (close
+// 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;
+}
+
+template <typename T>
+T FloatToSymmetricQuantizedType(const float value, const float scale) {
+  // 64-bit values are required since 8x16 conv accumulates to int64, meaning
+  // an int64 bias is required.
+  std::int64_t result = round(value / scale);
+  result = std::max(
+      static_cast<std::int64_t>(std::numeric_limits<T>::min() + 1), result);
+  result = std::min(static_cast<std::int64_t>(std::numeric_limits<T>::max()),
+                    result);
+  return result;
+}
+
+// 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
+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);
+  }
+}
+
+template <typename T>
+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);
+  }
+}
+
+template <typename T>
+void SymmetricPerChannelQuantize(const float* input, 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] = FloatToSymmetricQuantizedType<T>(
+          input[i * elements_per_channel + j], scales[i]);
+    }
+  }
+}
+
+void SignedSymmetricPerChannelQuantize(const float* values,
+                                       TfLiteIntArray* dims,
+                                       int quantized_dimension,
+                                       int8_t* quantized_values,
+                                       float* scaling_factor,
+                                       TfLiteType type = kTfLiteNoType);
+
+// Quantizes inputs based on the values provided, choosing the smallest range
+// which includes all input values.
+template <typename T>
+void SymmetricQuantizeCalculateScales(const float* values, TfLiteIntArray* dims,
+                                      T* output, float* scale) {
+  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]);
+  }
+  *scale = fmaxf(std::abs(min), std::abs(max)) / std::numeric_limits<T>::max();
+  for (int i = 0; i < input_size; i++) {
+    const int32_t quantized_value =
+        static_cast<int32_t>(roundf(values[i] / *scale));
+    // Clamp: just in case some odd numeric offset.
+    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 Dequantize(const T* values, const int size, const float scale,
+                int zero_point, float* dequantized_values) {
+  for (int i = 0; i < size; ++i) {
+    dequantized_values[i] = (values[i] - zero_point) * scale;
+  }
+}
+
+// based on TfLiteType passed in to these functions the corresponding max / min
+// int for that type are returned
+inline int QMinFromTfLiteType(TfLiteType type) {
+  if (type == kTfLiteInt4) {
+    return -8;
+  } else {
+    return std::numeric_limits<int8_t>::min();
+  }
+}
+
+inline int QMaxFromTfLiteType(TfLiteType type) {
+  if (type == kTfLiteInt4) {
+    return 7;
+  } else {
+    return std::numeric_limits<int8_t>::max();
+  }
+}
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_UTILS_H_

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

@@ -0,0 +1,60 @@
+/* Copyright 2021 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_MOCK_MICRO_GRAPH_H_
+#define TENSORFLOW_LITE_MICRO_MOCK_MICRO_GRAPH_H_
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_graph.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+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
+// validation of control flow operators.
+class MockMicroGraph : public MicroGraph {
+ public:
+  explicit MockMicroGraph(SingleArenaBufferAllocator* allocator);
+  TfLiteStatus InvokeSubgraph(int subgraph_idx) override;
+  size_t NumSubgraphInputs(int subgraph_idx) override;
+  TfLiteEvalTensor* GetSubgraphInput(int subgraph_idx, int tensor_idx) override;
+  size_t NumSubgraphOutputs(int subgraph_idx) override;
+  TfLiteEvalTensor* GetSubgraphOutput(int subgraph_idx,
+                                      int tensor_idx) override;
+  int NumSubgraphs() override;
+  MicroResourceVariables* GetResourceVariables() override;
+  int get_init_count() const { return init_count_; }
+  int get_prepare_count() const { return prepare_count_; }
+  int get_free_count() const { return free_count_; }
+  int get_invoke_count(int subgraph_idx) const {
+    return invoke_counts_[subgraph_idx];
+  }
+
+ private:
+  static constexpr int kMaxSubgraphs = 10;
+  SingleArenaBufferAllocator* allocator_;
+  TfLiteEvalTensor* mock_tensor_;
+  int init_count_;
+  int prepare_count_;
+  int free_count_;
+  int invoke_counts_[kMaxSubgraphs];
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MOCK_MICRO_GRAPH_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/python/interpreter/src/python_ops_resolver.h

@@ -0,0 +1,21 @@
+/* Copyright 2023 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_PYTHON_INTERPRETER_SRC_PYTHON_OPS_RESOLVER_H_
+#define TENSORFLOW_LITE_MICRO_PYTHON_INTERPRETER_SRC_PYTHON_OPS_RESOLVER_H_
+
+// TODO(b/286456378): remove once this shim is no longer needed.
+#include "python/tflite_micro/python_ops_resolver.h"
+
+#endif  // TENSORFLOW_LITE_MICRO_PYTHON_INTERPRETER_SRC_PYTHON_OPS_RESOLVER_H_

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

@@ -0,0 +1,30 @@
+/* Copyright 2022 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_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_H_
+#define TENSORFLOW_LITE_MICRO_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_H_
+
+#include <string>
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/util.h"
+
+namespace tflite_micro {
+
+std::string FlatBufferSizeToJsonString(
+    const uint8_t* buffer, const flatbuffers::TypeTable* type_table);
+
+}  // 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

@@ -0,0 +1,33 @@
+/* Copyright 2022 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_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_WRAPPER_H_
+#define TENSORFLOW_LITE_MICRO_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_WRAPPER_H_
+
+#include <Python.h>
+
+#include <string>
+
+namespace tflite_micro {
+
+class FlatbufferSizeWrapper {
+ public:
+  FlatbufferSizeWrapper();
+  ~FlatbufferSizeWrapper();
+
+  std::string ConvertToJsonString(const char* in_flatbuffer);
+};
+
+}  // namespace tflite_micro
+#endif  // TENSORFLOW_LITE_MICRO_PYTHON_TFLITE_SIZE_SRC_FLATBUFFERS_SIZE_WRAPPER_H_