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

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

@@ -0,0 +1,189 @@
+/* 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_INTERPRETER_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "flatbuffers/flatbuffers.h"  // from @flatbuffers
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/core/api/error_reporter.h"
+#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_interpreter_context.h"
+#include "tensorflow/lite/micro/micro_interpreter_graph.h"
+#include "tensorflow/lite/micro/micro_op_resolver.h"
+#include "tensorflow/lite/micro/micro_profiler_interface.h"
+#include "tensorflow/lite/portable_type_to_tflitetype.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+/// Copied from tensorflow/lite/version.h to avoid a dependency chain into
+// tensorflow/core.
+#define TFLITE_SCHEMA_VERSION (3)
+
+namespace tflite_micro {
+
+class MicroInterpreter {
+ public:
+  // The lifetime of the model, op resolver, tensor arena, error reporter,
+  // resource variables, and profiler must be at least as long as that of the
+  // interpreter object, since the interpreter may need to access them at any
+  // time. This means that you should usually create them with the same scope as
+  // each other, for example having them all allocated on the stack as local
+  // variables through a top-level function. The interpreter doesn't do any
+  // deallocation of any of the pointed-to objects, ownership remains with the
+  // caller.
+  MicroInterpreter(const Model* model, const MicroOpResolver& op_resolver,
+                   uint8_t* tensor_arena, size_t tensor_arena_size,
+                   MicroResourceVariables* resource_variables = nullptr,
+                   MicroProfilerInterface* profiler = nullptr,
+                   bool preserve_all_tensors = false);
+
+  // Create an interpreter instance using an existing MicroAllocator instance.
+  // This constructor should be used when creating an allocator that needs to
+  // have allocation handled in more than one interpreter or for recording
+  // allocations inside the interpreter. The lifetime of the allocator must be
+  // as long as that of the interpreter object.
+  MicroInterpreter(const Model* model, const MicroOpResolver& op_resolver,
+                   MicroAllocator* allocator,
+                   MicroResourceVariables* resource_variables = nullptr,
+                   MicroProfilerInterface* profiler = nullptr);
+
+  ~MicroInterpreter();
+
+  // Runs through the model and allocates all necessary input, output and
+  // intermediate tensors.
+  TfLiteStatus AllocateTensors();
+
+  // In order to support partial graph runs for strided models, this can return
+  // values other than kTfLiteOk and kTfLiteError.
+  // TODO(b/149795762): Add this to the TfLiteStatus enum.
+  TfLiteStatus Invoke();
+
+  // This is the recommended API for an application to pass an external payload
+  // pointer as an external context to kernels. The life time of the payload
+  // pointer should be at least as long as this interpreter. TFLM supports only
+  // one external context.
+  TfLiteStatus SetMicroExternalContext(void* external_context_payload);
+
+  TfLiteTensor* input(size_t index);
+  size_t inputs_size() const {
+    return model_->subgraphs()->Get(0)->inputs()->size();
+  }
+  const flatbuffers::Vector<int32_t>& inputs() const {
+    return *model_->subgraphs()->Get(0)->inputs();
+  }
+  TfLiteTensor* input_tensor(size_t index) { return input(index); }
+  template <class T>
+  T* typed_input_tensor(int tensor_index) {
+    if (TfLiteTensor* tensor_ptr = input_tensor(tensor_index)) {
+      if (tensor_ptr->type == typeToTfLiteType<T>()) {
+        return GetTensorData<T>(tensor_ptr);
+      }
+    }
+    return nullptr;
+  }
+
+  TfLiteTensor* output(size_t index);
+  size_t outputs_size() const {
+    return model_->subgraphs()->Get(0)->outputs()->size();
+  }
+  const flatbuffers::Vector<int32_t>& outputs() const {
+    return *model_->subgraphs()->Get(0)->outputs();
+  }
+  TfLiteTensor* output_tensor(size_t index) { return output(index); }
+  template <class T>
+  T* typed_output_tensor(int tensor_index) {
+    if (TfLiteTensor* tensor_ptr = output_tensor(tensor_index)) {
+      if (tensor_ptr->type == typeToTfLiteType<T>()) {
+        return GetTensorData<T>(tensor_ptr);
+      }
+    }
+    return nullptr;
+  }
+
+  // Returns a pointer to the tensor for the corresponding tensor_index
+  TfLiteEvalTensor* GetTensor(int tensor_index, int subgraph_index = 0);
+
+  // Reset the state to be what you would expect when the interpreter is first
+  // created. i.e. after Init and Prepare is called for the very first time.
+  TfLiteStatus Reset();
+
+  TfLiteStatus initialization_status() const { return initialization_status_; }
+
+  // Populates node and registration pointers representing the inference graph
+  // of the model from values inside the flatbuffer (loaded from the TfLiteModel
+  // instance). Persistent data (e.g. operator data) is allocated from the
+  // arena.
+  TfLiteStatus PrepareNodeAndRegistrationDataFromFlatbuffer();
+
+  // For debugging only.
+  // Returns the actual used arena in bytes. This method gives the optimal arena
+  // size. It's only available after `AllocateTensors` has been called.
+  // Note that normally `tensor_arena` requires 16 bytes alignment to fully
+  // utilize the space. If it's not the case, the optimial arena size would be
+  // arena_used_bytes() + 16.
+  size_t arena_used_bytes() const { return allocator_.used_bytes(); }
+
+  // Returns True if all Tensors are being preserves
+  // TODO(b/297106074) : revisit making C++ example or test for
+  // preserve_all_tesnors
+  bool preserve_all_tensors() const {
+    return allocator_.preserves_all_tensor();
+  }
+
+  size_t operators_size(int sg) const { return model_->subgraphs()->Get(sg)->operators()->size(); }
+
+  // For debugging only.
+  const NodeAndRegistration node_and_registration(int node_index, int sg)  {
+    return graph_.GetAllocations()[sg].node_and_registrations[node_index];
+  }
+
+ protected:
+  const MicroAllocator& allocator() const { return allocator_; }
+  const TfLiteContext& context() const { return context_; }
+
+ private:
+  // TODO(b/158263161): Consider switching to Create() function to enable better
+  // error reporting during initialization.
+  void Init(MicroProfilerInterface* profiler);
+
+  // Gets the current subgraph index used from within context methods.
+  int get_subgraph_index() { return graph_.GetCurrentSubgraphIndex(); }
+
+  const Model* model_;
+  const MicroOpResolver& op_resolver_;
+  TfLiteContext context_ = {};
+  MicroAllocator& allocator_;
+  MicroInterpreterGraph graph_;
+  bool tensors_allocated_;
+
+  TfLiteStatus initialization_status_;
+
+  ScratchBufferHandle* scratch_buffer_handles_ = nullptr;
+
+  // TODO(b/162311891): Clean these pointers up when this class supports buffers
+  // from TfLiteEvalTensor.
+  TfLiteTensor** input_tensors_;
+  TfLiteTensor** output_tensors_;
+
+  MicroInterpreterContext micro_context_;
+};
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_H_

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

@@ -0,0 +1,125 @@
+/* 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_MICRO_INTERPRETER_CONTEXT_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_CONTEXT_H_
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_context.h"
+#include "tensorflow/lite/micro/micro_interpreter_graph.h"
+#include "tensorflow/lite/micro/micro_log.h"
+
+namespace tflite_micro {
+
+// A full implementation of the MicroContext, to be used by the
+// MicroInterpreter. Kernels should not depend on this directly. Instead they
+// should only depend on the MicroContext.
+class MicroInterpreterContext : public MicroContext {
+ public:
+  // Enum that allows MicroContext to keep track of the stages different memory
+  // planning APIs are available to kernels.
+  enum class InterpreterState {
+    kInit,
+    kPrepare,
+    kMemoryPlanning,
+    kInvoke,
+  };
+
+  // Does not take any ownership, and all pointers must refer to valid objects
+  // that outlive the one constructed.
+  MicroInterpreterContext(MicroAllocator* allocator, const Model* model,
+                          MicroInterpreterGraph* graph);
+  virtual ~MicroInterpreterContext();
+
+  // Allocate persistent buffer which has the same life time as the interpreter.
+  // Returns nullptr on failure.
+  // The memory is allocated from the tail.
+  // This method is only available in Init or Prepare stage.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void* AllocatePersistentBuffer(size_t bytes) override;
+
+  // Request a scratch buffer in the arena through static memory planning.
+  // This method is only available in Prepare stage and the buffer is allocated
+  // by the interpreter between Prepare and Eval stage. In Eval stage,
+  // GetScratchBuffer API can be used to fetch the address.
+  // Virtual so that it can be faked for kernel tests.
+  virtual TfLiteStatus RequestScratchBufferInArena(size_t bytes,
+                                                   int* buffer_idx) override;
+
+  // Get the scratch buffer pointer.
+  // This method is only available in Eval stage.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void* GetScratchBuffer(int buffer_idx) override;
+
+  // Returns a temporary TfLiteTensor struct for a given index.
+  // Virtual so that it can be faked for kernel tests.
+  virtual TfLiteTensor* AllocateTempTfLiteTensor(int tensor_idx) override;
+  virtual TfLiteTensor* AllocateTempTfLiteTensor(int tensor_idx, int sg) override;
+
+  // Deallocates a temp TfLiteTensor.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void DeallocateTempTfLiteTensor(TfLiteTensor* tensor) override;
+
+  // Returns a pointer to a temporary buffer (from the arena).
+  // This API is only valid from the kernel's Prepare function and
+  // the buffer's lifetime is also that of the Prepare function.
+  // Virtual so that it can be faked for kernel tests.
+  virtual uint8_t* AllocateTempBuffer(size_t size, size_t alignment) override;
+
+  // Signals that the temporary buffer is no longer needed.
+  // Virtual so that it can be faked for kernel tests.
+  virtual void DeallocateTempBuffer(uint8_t* buffer) override;
+
+  // Returns a TfLiteEvalTensor struct for a given index.
+  // Virtual so that it can be faked for kernel tests.
+  virtual TfLiteEvalTensor* GetEvalTensor(int tensor_idx) override;
+  virtual TfLiteEvalTensor* GetEvalTensor(int tensor_idx, int sg) override;
+
+  // Sets the State of MemoryPlanning MicroInterpreterContext
+  void SetInterpreterState(InterpreterState state);
+
+  // Sets the State of MemoryPlanning MicroInterpreterContext
+  InterpreterState GetInterpreterState() const;
+
+  // Does not take ownership of the pointer and the pointer must refer to valid
+  // an object that outlive this class instance.
+  // This can only be called once to set one external context.
+  TfLiteStatus set_external_context(void* external_context_payload) override;
+
+  void* external_context() override { return external_context_payload_; }
+
+  MicroGraph& graph() override { return graph_; }
+
+  // Sets the pointer to a list of ScratchBufferHandle instances.
+  // Not API between TFLM and kernels. Primarily used by the framework for
+  // housekeeping in MicroInterpreterContext.
+  void SetScratchBufferHandles(ScratchBufferHandle* scratch_buffer_handles);
+
+ private:
+  MicroAllocator& allocator_;
+  MicroInterpreterGraph& graph_;
+  const Model* model_;
+  InterpreterState state_;
+
+  ScratchBufferHandle* scratch_buffer_handles_ = nullptr;
+  void* external_context_payload_ = nullptr;
+
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_CONTEXT_H_

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

@@ -0,0 +1,110 @@
+/* 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_MICRO_INTERPRETER_GRAPH_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_GRAPH_H_
+
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_common.h"
+#include "tensorflow/lite/micro/micro_graph.h"
+#include "tensorflow/lite/micro/micro_resource_variable.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+namespace tflite_micro {
+
+// Abstracts the details of interacting with the tflite_micro::Model.
+//
+// Provides methods to access, initialize, prepare, invoke and free any
+// subgraph in the tflite_micro::Graph.
+class MicroInterpreterGraph : public MicroGraph {
+ public:
+  // The lifetime of the context, model, allocator and resource_variables must
+  // be at least as long as that of the graph object, since the this class may
+  // need to access them at any time. If resource_variables is a nullptr,
+  // GetResourceVariables will return a nullptr.
+  MicroInterpreterGraph(TfLiteContext* context, const Model* model,
+                        MicroAllocator* allocator,
+                        MicroResourceVariables* resource_variables);
+  virtual ~MicroInterpreterGraph();
+
+  // Sets up builtin data and calls TFLMRegistration->Init for every
+  // operator in every subgraph in the model.
+  virtual TfLiteStatus InitSubgraphs();
+
+  // Calls TFLMRegistration->Prepare for every operator in every subgraph
+  // in the model.
+  virtual TfLiteStatus PrepareSubgraphs();
+
+  // Calls TFLMRegistration->Reset for every operator in every subgraph in
+  // the model.
+  virtual TfLiteStatus ResetSubgraphs();
+
+  // Calls TFLMRegistration->Free for every operator in every subgraph in
+  // the model.
+  virtual TfLiteStatus FreeSubgraphs();
+
+  // Calls TFLMRegistration->Invoke for every operator in a single subgraph
+  // in the model.
+  virtual TfLiteStatus InvokeSubgraph(int subgraph_idx);
+
+  // Zeros out all variable tensors in all subgraphs in the model.
+  virtual TfLiteStatus ResetVariableTensors();
+
+  // Number of tensor inputs to a specified subgraph in the model.
+  virtual size_t NumSubgraphInputs(int subgraph_idx);
+
+  // Get the specified input tensor of a specified subgraph in the model.
+  virtual TfLiteEvalTensor* GetSubgraphInput(int subgraph_idx, int input_idx);
+
+  // Number of tensor outputs from a specified subgraph in the model.
+  virtual size_t NumSubgraphOutputs(int subgraph_idx);
+
+  // Get the specified output tensor of a specified subgraph in the model.
+  virtual TfLiteEvalTensor* GetSubgraphOutput(int subgraph_idx, int output_idx);
+
+  // Number of subgraphs in the model.
+  virtual int NumSubgraphs();
+
+  // Hook to pass in subgraph allocations tracked within the interpreter,
+  // allowing MicroInterpreterGraph to init / prepare / invoke subgraphs in the
+  // model.
+  void SetSubgraphAllocations(SubgraphAllocations* subgraph_allocations);
+
+  // Get the current subgraph index. Within an on operator, this is guaranteed
+  // to be the subgraph of that operator.
+  int GetCurrentSubgraphIndex() { return current_subgraph_index_; }
+
+  // Gets the list of alloctions for each subgraph. This is the source of truth
+  // for all per-subgraph allocation data.
+  SubgraphAllocations* GetAllocations() { return subgraph_allocations_; }
+
+  // Get the resource variables for this TFLM graph.
+  MicroResourceVariables* GetResourceVariables() { return resource_variables_; }
+
+ private:
+  TfLiteContext* context_;
+  const Model* model_;
+  MicroAllocator* allocator_;
+  SubgraphAllocations* subgraph_allocations_ = nullptr;
+  int current_subgraph_index_;
+  MicroResourceVariables* resource_variables_;
+  const flatbuffers::Vector<flatbuffers::Offset<SubGraph>>* subgraphs_;
+
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_INTERPRETER_GRAPH_H_

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

@@ -0,0 +1,42 @@
+/* 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_MICRO_LOG_H_
+#define TENSORFLOW_LITE_MICRO_MICRO_LOG_H_
+
+#if !defined(TF_LITE_STRIP_ERROR_STRINGS)
+#include <cstdarg>
+// These functions can be used independent of the MicroErrorReporter to get
+// printf-like functionalitys and are common to all target platforms.
+void MicroPrintf(const char* format, ...);
+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_micro::Unused(__VA_ARGS__)
+#define VMicroPrintf(...) tflite_micro::Unused(__VA_ARGS__)
+#endif
+
+namespace tflite_micro {
+
+// From
+// https://stackoverflow.com/questions/23235910/variadic-unused-function-macro
+template <typename... Args>
+void Unused(Args&&... args) {
+  (void)(sizeof...(args));
+}
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_MICRO_LOG_H_