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

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/activations.h

@@ -0,0 +1,64 @@
+/* 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_KERNELS_ACTIVATIONS_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_ACTIVATIONS_H_
+
+#include <cstdint>
+
+#include "tensorflow/lite/c/builtin_op_data.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/types.h"
+
+namespace tflite_micro {
+
+extern const int kActivationsInputTensor;
+extern const int kActivationsOutputTensor;
+
+struct ReluOpData {
+  ReluParams params;
+};
+
+struct Relu6OpData {
+  int8_t six_int8;
+  int8_t zero_int8;
+};
+
+template <typename T>
+void ReluQuantized(const ReluOpData& data, const RuntimeShape& input_shape,
+                   const RuntimeShape& output_shape, const T* input_data,
+                   T* output_data);
+
+template <typename T>
+void CalculateReluOpData(const TfLiteTensor* input, TfLiteTensor* output,
+                         ReluOpData* data);
+
+void ReluFloat(const RuntimeShape& input_shape, const float* input_data,
+               const RuntimeShape& output_shape, float* output_data);
+
+void Relu6Float(const RuntimeShape& input_shape, const float* input_data,
+                const RuntimeShape& output_shape, float* output_data);
+
+void Relu6Quantized(int8_t lower, int8_t upper, const RuntimeShape& input_shape,
+                    const int8_t* input_data, const RuntimeShape& output_shape,
+                    int8_t* output_data);
+
+TfLiteStatus ReluPrepare(TfLiteContext* context, TfLiteNode* node);
+
+TfLiteStatus Relu6Prepare(TfLiteContext* context, TfLiteNode* node);
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_ACTIVATIONS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/add.h

@@ -0,0 +1,78 @@
+/* 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_KERNELS_ADD_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_ADD_H_
+
+#include <cstdint>
+
+#include "tensorflow/lite/c/builtin_op_data.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_common.h"
+
+namespace tflite_micro {
+
+extern const int kAddInputTensor1;
+extern const int kAddInputTensor2;
+extern const int kAddOutputTensor;
+
+struct OpDataAdd {
+  bool requires_broadcast;
+
+  // These fields are used in both the general 8-bit -> 8bit quantized path,
+  // and the special 16-bit -> 16bit quantized path
+  int input1_shift;
+  int input2_shift;
+  int32_t output_activation_min;
+  int32_t output_activation_max;
+
+  // These fields are used only in the general 8-bit -> 8bit quantized path
+  int32_t input1_multiplier;
+  int32_t input2_multiplier;
+  int32_t output_multiplier;
+  int output_shift;
+  int left_shift;
+  int32_t input1_offset;
+  int32_t input2_offset;
+  int32_t output_offset;
+
+  // Used only for float evals:
+  float output_activation_min_f32;
+  float output_activation_max_f32;
+};
+
+TfLiteStatus CalculateOpDataAdd(TfLiteContext* context, TfLiteAddParams* params,
+                                const TfLiteTensor* input1,
+                                const TfLiteTensor* input2,
+                                TfLiteTensor* output, OpDataAdd* data);
+
+TfLiteStatus AddPrepare(TfLiteContext* context, TfLiteNode* node);
+
+// Generic must define registration function.
+TFLMRegistration Register_ADD();
+
+#if defined(CMSIS_NN)
+TFLMRegistration Register_ADD_INT8();
+
+TFLMRegistration Register_ADD_INT16();
+#else
+// Fallback registration
+inline TFLMRegistration Register_ADD_INT8() { return Register_ADD(); }
+
+inline TFLMRegistration Register_ADD_INT16() { return Register_ADD(); }
+#endif
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_ADD_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/arc_mli/mli_function_specializations.h

@@ -0,0 +1,141 @@
+/* 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.
+==============================================================================*/
+
+#include "mli_api.h"  // NOLINT
+
+namespace tflite_micro {
+
+// Convolution specialized function.
+typedef mli_status (*conv_func_ptr)(const mli_tensor* /*in*/,
+                                    const mli_tensor* /*weights*/,
+                                    const mli_tensor* /*bias*/,
+                                    const mli_conv2d_cfg* /*cfg*/,
+                                    mli_tensor* /*out*/);
+
+#ifdef MLI_2_0
+conv_func_ptr __attribute__((weak))
+mli_krn_conv2d_hwcn(const mli_tensor* weights) {
+  int filter_w = weights->shape[KRNL_W_DIM_HWCN];
+  int filter_h = weights->shape[KRNL_H_DIM_HWCN];
+
+  if (filter_w == 1 && filter_h == 1) {
+    return mli_krn_conv2d_hwcn_sa8_sa8_sa32_k1x1;
+  } else if (filter_w == 3 && filter_h == 3) {
+    return mli_krn_conv2d_hwcn_sa8_sa8_sa32_k3x3;
+  } else if (filter_w == 5 && filter_h == 5) {
+    return mli_krn_conv2d_hwcn_sa8_sa8_sa32_k5x5;
+  } else {
+    return mli_krn_conv2d_hwcn_sa8_sa8_sa32;
+  }
+}
+#else
+conv_func_ptr __attribute__((weak))
+mli_krn_conv2d_hwcn(const mli_tensor* weights, const mli_conv2d_cfg* cfg) {
+  return mli_krn_conv2d_nhwc_sa8_sa8_sa32;
+}
+#endif
+
+// Depthwise convolution specialized function.
+typedef mli_status (*depthwise_func_ptr)(const mli_tensor* /*in*/,
+                                         const mli_tensor* /*weights*/,
+                                         const mli_tensor* /*bias*/,
+                                         const mli_conv2d_cfg* /*cfg*/,
+                                         mli_tensor* /*out*/);
+
+#ifdef MLI_2_0
+depthwise_func_ptr __attribute__((weak))
+mli_krn_depthwise_conv2d(const mli_tensor* weights) {
+  int filter_w = weights->shape[KRNL_DW_W_DIM_HW1N];
+  int filter_h = weights->shape[KRNL_DW_H_DIM_HW1N];
+
+  if (filter_w == 3 && filter_h == 3) {
+    return mli_krn_depthwise_conv2d_hwcn_sa8_sa8_sa32_k3x3;
+  } else if (filter_w == 5 && filter_h == 5) {
+    return mli_krn_depthwise_conv2d_hwcn_sa8_sa8_sa32_k5x5;
+  } else {
+    return mli_krn_depthwise_conv2d_hwcn_sa8_sa8_sa32;
+  }
+}
+#else
+depthwise_func_ptr __attribute__((weak))
+mli_krn_depthwise_conv2d(const mli_tensor* weights, const mli_conv2d_cfg* cfg) {
+  return mli_krn_depthwise_conv2d_hwcn_sa8_sa8_sa32;
+}
+#endif
+
+#ifdef MLI_2_0
+depthwise_func_ptr __attribute__((weak))
+mli_krn_group_conv2d(const mli_tensor* weights) {
+  int filter_w = weights->shape[KRNL_DW_W_DIM_HW1N];
+  int filter_h = weights->shape[KRNL_DW_H_DIM_HW1N];
+
+  if (filter_w == 3 && filter_h == 3) {
+    return mli_krn_group_conv2d_hwcn_sa8_sa8_sa32_k3x3;
+  } else if (filter_w == 5 && filter_h == 5) {
+    return mli_krn_group_conv2d_hwcn_sa8_sa8_sa32_k5x5;
+  } else {
+    return mli_krn_group_conv2d_hwcn_sa8_sa8_sa32;
+  }
+}
+#endif
+
+// Pooling specialized functions.
+typedef mli_status (*pooling_func_ptr)(const mli_tensor* /*in*/,
+                                       const mli_pool_cfg* /*cfg*/,
+                                       mli_tensor* /*out*/);
+
+#ifdef MLI_2_0
+pooling_func_ptr __attribute__((weak))
+mli_krn_avepool(const mli_pool_cfg* cfg) {
+  int filter_w = cfg->kernel_width;
+  int filter_h = cfg->kernel_height;
+
+  if (filter_w == 2 && filter_h == 2) {
+    return mli_krn_avepool_hwc_sa8_k2x2;
+  } else if (filter_w == 3 && filter_h == 3) {
+    return mli_krn_avepool_hwc_sa8_k3x3;
+  } else {
+    return mli_krn_avepool_hwc_sa8;
+  }
+}
+#else
+pooling_func_ptr __attribute__((weak))
+mli_krn_avepool(const mli_pool_cfg* cfg) {
+  return mli_krn_avepool_hwc_sa8;
+}
+#endif
+
+#ifdef MLI_2_0
+pooling_func_ptr __attribute__((weak))
+mli_krn_maxpool(const mli_pool_cfg* cfg) {
+  int filter_w = cfg->kernel_width;
+  int filter_h = cfg->kernel_height;
+
+  if (filter_w == 2 && filter_h == 2) {
+    return mli_krn_maxpool_hwc_sa8_k2x2;
+  } else if (filter_w == 3 && filter_h == 3) {
+    return mli_krn_maxpool_hwc_sa8_k3x3;
+  } else {
+    return mli_krn_maxpool_hwc_sa8;
+  }
+}
+#else
+pooling_func_ptr __attribute__((weak))
+mli_krn_maxpool(const mli_pool_cfg* cfg) {
+  return mli_krn_maxpool_hwc_sa8;
+}
+#endif
+
+}  // namespace tflite_micro

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/arc_mli/mli_interface.h

@@ -0,0 +1,75 @@
+/* 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_KERNELS_ARC_MLI_INTERFACE_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_ARC_MLI_INTERFACE_H_
+
+#include "mli_api.h"  // NOLINT
+#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
+namespace tflite_micro {
+namespace ops {
+namespace micro {
+
+// Abstracts access to mli_tensor fields to use different versions of MLI
+// Library (1.x and 2.x)
+// Example:
+//    ops::micro::MliTensorInterface mli_in =
+//    ops::micro::MliTensorInterface(static_cast<mli_tensor*>(
+//        context->AllocatePersistentBuffer(context, sizeof(mli_tensor))));
+
+class MliTensorInterface {
+ public:
+  // Make sure that lifetime of MliTensorInterface instance isn't bigger than
+  // related mli_tensor.
+  MliTensorInterface(mli_tensor* tensor) : tensor_(tensor){};
+  MliTensorInterface() = default;
+  ~MliTensorInterface() = default;
+
+  template <typename T>
+  T* Data();
+  template <typename T>
+  T Scale();
+  template <typename T>
+  T ZeroPoint();
+  template <typename T>
+  T ScaleFracBits();
+  mli_tensor* MliTensor();
+  const mli_tensor* MliTensor() const;
+  int32_t* Dim();
+  uint32_t* Rank();
+  uint32_t* Shape();
+  const uint32_t* Shape() const;
+  const uint32_t* DataCapacity() const;
+  uint32_t* ScaleCapacity();
+  mli_element_type* ElType();
+  uint32_t* ScaleFracBitsCapacity();
+  int32_t* MemStride();
+  uint32_t* ZeroPointCapacity();
+
+  template <typename T>
+  void SetData(T* data, uint32_t capacity) const;
+  void SetScale(float fscale);
+  void SetScalePerChannel(float* fscale, const int num_channels);
+  void SetElType(TfLiteType type);
+
+ private:
+  mli_tensor* tensor_;
+};
+
+}  // namespace micro
+}  // namespace ops
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_ARC_MLI_SLICERS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/arc_mli/mli_slicers.h

@@ -0,0 +1,56 @@
+/* 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_KERNELS_ARC_MLI_SLICERS_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_ARC_MLI_SLICERS_H_
+
+#include "mli_api.h"  // NOLINT
+namespace tflite_micro {
+namespace ops {
+namespace micro {
+
+class TensorSlicer {
+ public:
+  TensorSlicer(const mli_tensor* full_tensor, int slice_dim, int slice_size,
+               int padding_pre = 0, int padding_post = 0, int overlap = 0,
+               bool interleave_mode = false);
+  ~TensorSlicer() = default;
+
+  void Next();
+  bool Done();
+  int GetPaddingPre();
+  int GetPaddingPost();
+
+  mli_tensor* Sub();
+
+  // Default constructor is deleted
+  TensorSlicer() = delete;
+
+ private:
+  const mli_tensor* full_tensor_;
+  mli_tensor sub_tensor_;
+  mli_sub_tensor_cfg sub_cfg_;
+  bool done_;
+  int sliceDim_;
+  int pad_pre_, pad_post_, overlap_;
+  int actual_padding_pre, actual_padding_post;
+
+  void ComputeSubTensor();
+};
+
+}  // namespace micro
+}  // namespace ops
+}  // namespace tflite_micro
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_ARC_MLI_SLICERS_H_