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

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

@@ -0,0 +1,150 @@
+/* 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_KERNELS_LSTM_SHARED_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_LSTM_SHARED_H_
+
+#include "tensorflow/lite/c/builtin_op_data.h"
+#include "tensorflow/lite/kernels/internal/types.h"
+
+namespace tflite_micro {
+
+// Input Tensors of size {n_batch, n_input}
+constexpr int kLstmInputTensor = 0;
+
+// Input weight tensors of size: {n_cell, n_input}
+constexpr int kLstmInputToInputWeightsTensor = 1;  // Optional
+constexpr int kLstmInputToForgetWeightsTensor = 2;
+constexpr int kLstmInputToCellWeightsTensor = 3;
+constexpr int kLstmInputToOutputWeightsTensor = 4;
+
+// Recurrent weight tensors of size {n_cell, n_output}
+constexpr int kLstmRecurrentToInputWeightsTensor = 5;  // Optional
+constexpr int kLstmRecurrentToForgetWeightsTensor = 6;
+constexpr int kLstmRecurrentToCellWeightsTensor = 7;
+constexpr int kLstmRecurrentToOutputWeightsTensor = 8;
+
+// Peephole weights tensors of size {n_cell}, representing a diagonal matrix.
+constexpr int kLstmCellToInputWeightsTensor = 9;    // Optional
+constexpr int kLstmCellToForgetWeightsTensor = 10;  // Optional
+constexpr int kLstmCellToOutputWeightsTensor = 11;  // Optional
+
+// Gates bias tensors of size {n_cell}
+constexpr int kLstmInputGateBiasTensor = 12;  // Optional
+constexpr int kLstmForgetGateBiasTensor = 13;
+constexpr int kLstmCellGateBiasTensor = 14;
+constexpr int kLstmOutputGateBiasTensor = 15;
+
+// Projection weight tensor of size {n_output, n_cell}
+constexpr int kLstmProjectionWeightsTensor = 16;  // Optional
+// Projection bias tensor of size {n_output}
+constexpr int kLstmProjectionBiasTensor = 17;  // Optional
+
+// These state tensors are defined as variable tensors, and will be modified by
+// this op.
+constexpr int kLstmOutputStateTensor = 18;
+constexpr int kLstmCellStateTensor = 19;
+
+// Layer norm coefficient tensors of size {n_cell}, representing a diagonal
+// matrix.
+constexpr int kLstmInputLayerNormCoefficientsTensor = 20;   // Optional
+constexpr int kLstmForgetLayerNormCoefficientsTensor = 21;  // Optional
+constexpr int kLstmCellLayerNormCoefficientsTensor = 22;    // Optional
+constexpr int kLstmOutputLayerNormCoefficientsTensor = 23;  // Optional
+
+// Output tensors.
+constexpr int kLstmOutputTensor = 0;
+
+// Parameters for the two fully conncted computation inside each gate
+struct GateParameters {
+  FullyConnectedParams input_fc_params;
+  FullyConnectedParams recurrent_fc_params;
+};
+
+// Paramaters for the element wise multiplications between gate outputs
+struct InterGateParameters {
+  ArithmeticParams forget_cell_mul_params;
+  ArithmeticParams input_mul_params;
+  ArithmeticParams output_mul_params;
+};
+
+// Size information about the LSTM kernel, which is deduced from tensors stored
+// in the flat buffer file.
+struct LstmSizeInfo {
+  bool time_major;
+  int batch_size;
+  int time_steps;
+  int input_dimension;
+  int state_dimension;
+};
+
+// Contains information about the cell state tensor
+struct CellStateInfo {
+  float cell_clip;
+  // clipping range for cell state only 16 bits cell is supported (could be
+  // generalized through templatation)
+  int16_t quantized_cell_clip;
+  // 2^-cell_state_scale_power = cell state scale, required by integer tanh
+  // computation
+  int32_t cell_state_scale_power;
+};
+
+// Contains required computation information for LSTM kernel evaluation.
+// Specifically, it includes shape and quantization settings for the LSTM
+// internal operations. Formatted to support operations defined in the
+// tensorflow/lite/kernels/internal/reference/integer_ops
+// Should be constructed during the preparation phase
+struct OpDataLSTM {
+  LstmSizeInfo size_info;
+  CellStateInfo cell_state_info;
+  TfLiteFusedActivation cell_gate_nonlinear_type;
+  GateParameters forget_gate_parameters;
+  GateParameters input_gate_parameters;
+  GateParameters cell_gate_parameters;
+  GateParameters output_gate_parameters;
+  InterGateParameters inter_gate_parameters;
+  int buffer_indices[4];  // TFLM only
+};
+
+// Provide an interface to access the internal tensors and buffers used for LSTM
+// invocation. Constructed during the invocation phase
+struct LSTMKernelContents {
+ public:
+  // Internal tensors, fixed (const). see lstm_shared.h for tensor names
+  const TfLiteEvalTensor* GetInternalTensor(const int tensor_index) const {
+    return internal_tensors[tensor_index];
+  }
+  // Variable tensors (will be changed, can not be const)
+  TfLiteEvalTensor* HiddenStateTensor() {
+    return internal_tensors[kLstmOutputStateTensor];
+  }
+  TfLiteEvalTensor* CellStateTensor() {
+    return internal_tensors[kLstmCellStateTensor];
+  }
+  // Node internal tensors with indexes defined at the beginning of the file
+  TfLiteEvalTensor* internal_tensors[24];
+  TfLiteEvalTensor* output_tensor;
+};
+
+template <typename CellType>
+struct LSTMBuffers {
+  // TFLM buffers requires buffer index from LstmOpData.
+  CellType* buffer0;
+  CellType* buffer1;
+  CellType* buffer2;
+  CellType* buffer3;
+};
+
+}  // namespace tflite_micro
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_LSTM_SHARED_H_

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

@@ -0,0 +1,158 @@
+/* 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_KERNELS_MICRO_OPS_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_MICRO_OPS_H_
+
+#include "signal/micro/kernels/irfft.h"
+#include "signal/micro/kernels/rfft.h"
+#include "tensorflow/lite/c/common.h"
+
+// Forward declaration of all micro op kernel registration methods. These
+// registrations are included with the standard `BuiltinOpResolver`.
+//
+// This header is particularly useful in cases where only a subset of ops are
+// needed. In such cases, the client can selectively add only the registrations
+// their model requires, using a custom `(Micro)MutableOpResolver`. Selective
+// registration in turn allows the linker to strip unused kernels.
+
+namespace tflite_micro {
+
+// TFLM is incrementally moving towards a flat tflite namespace
+// (https://abseil.io/tips/130). Any new ops (or cleanup of existing ops should
+// have their Register function declarations in the tflite namespace.
+
+TFLMRegistration Register_ABS();
+TFLMRegistration Register_ADD();
+TFLMRegistration Register_ADD_N();
+TFLMRegistration Register_ARG_MAX();
+TFLMRegistration Register_ARG_MIN();
+TFLMRegistration Register_ASSIGN_VARIABLE();
+TFLMRegistration Register_AVERAGE_POOL_2D();
+TFLMRegistration Register_BATCH_MATMUL();
+TFLMRegistration Register_BATCH_TO_SPACE_ND();
+TFLMRegistration Register_BROADCAST_ARGS();
+TFLMRegistration Register_BROADCAST_TO();
+TFLMRegistration Register_CALL_ONCE();
+TFLMRegistration Register_CAST();
+TFLMRegistration Register_CEIL();
+// TODO(b/160234179): Change custom OPs to also return by value.
+TFLMRegistration* Register_CIRCULAR_BUFFER();
+TFLMRegistration Register_CONCATENATION();
+TFLMRegistration Register_CONV_2D();
+TFLMRegistration Register_COS();
+TFLMRegistration Register_CUMSUM();
+TFLMRegistration Register_DEPTH_TO_SPACE();
+TFLMRegistration Register_DEPTHWISE_CONV_2D();
+TFLMRegistration Register_DEQUANTIZE();
+TFLMRegistration Register_DIV();
+TFLMRegistration Register_ELU();
+TFLMRegistration Register_EMBEDDING_LOOKUP();
+TFLMRegistration Register_EQUAL();
+TFLMRegistration* Register_ETHOSU();
+TFLMRegistration Register_EXP();
+TFLMRegistration Register_EXPAND_DIMS();
+TFLMRegistration Register_FILL();
+TFLMRegistration Register_FLOOR();
+TFLMRegistration Register_FLOOR_DIV();
+TFLMRegistration Register_FLOOR_MOD();
+TFLMRegistration Register_FULLY_CONNECTED();
+TFLMRegistration Register_GATHER();
+TFLMRegistration Register_GATHER_ND();
+TFLMRegistration Register_GREATER();
+TFLMRegistration Register_GREATER_EQUAL();
+TFLMRegistration Register_HARD_SWISH();
+TFLMRegistration Register_IF();
+TFLMRegistration Register_L2_NORMALIZATION();
+TFLMRegistration Register_L2_POOL_2D();
+TFLMRegistration Register_LEAKY_RELU();
+TFLMRegistration Register_LESS();
+TFLMRegistration Register_LESS_EQUAL();
+TFLMRegistration Register_LOG();
+TFLMRegistration Register_LOG_SOFTMAX();
+TFLMRegistration Register_LOGICAL_AND();
+TFLMRegistration Register_LOGICAL_NOT();
+TFLMRegistration Register_LOGICAL_OR();
+TFLMRegistration Register_LOGISTIC();
+TFLMRegistration Register_MAX_POOL_2D();
+TFLMRegistration Register_MAXIMUM();
+TFLMRegistration Register_MEAN();
+TFLMRegistration Register_MINIMUM();
+TFLMRegistration Register_MIRROR_PAD();
+TFLMRegistration Register_MUL();
+TFLMRegistration Register_NEG();
+TFLMRegistration Register_NOT_EQUAL();
+TFLMRegistration Register_PACK();
+TFLMRegistration Register_PAD();
+TFLMRegistration Register_PADV2();
+TFLMRegistration Register_PRELU();
+TFLMRegistration Register_QUANTIZE();
+TFLMRegistration Register_READ_VARIABLE();
+TFLMRegistration Register_REDUCE_MAX();
+TFLMRegistration Register_RELU();
+TFLMRegistration Register_RELU6();
+TFLMRegistration Register_RESHAPE();
+TFLMRegistration Register_RESIZE_BILINEAR();
+TFLMRegistration Register_RESIZE_NEAREST_NEIGHBOR();
+TFLMRegistration Register_ROUND();
+TFLMRegistration Register_RSQRT();
+TFLMRegistration Register_SELECT_V2();
+TFLMRegistration Register_SHAPE();
+TFLMRegistration Register_SIN();
+TFLMRegistration Register_SLICE();
+TFLMRegistration Register_SOFTMAX();
+TFLMRegistration Register_SPACE_TO_BATCH_ND();
+TFLMRegistration Register_SPACE_TO_DEPTH();
+TFLMRegistration Register_SPLIT();
+TFLMRegistration Register_SPLIT_V();
+TFLMRegistration Register_SQRT();
+TFLMRegistration Register_SQUARE();
+TFLMRegistration Register_SQUARED_DIFFERENCE();
+TFLMRegistration Register_SQUEEZE();
+TFLMRegistration Register_STRIDED_SLICE();
+TFLMRegistration Register_SUB();
+TFLMRegistration Register_SUM();
+TFLMRegistration Register_SVDF();
+TFLMRegistration Register_TANH();
+TFLMRegistration Register_TRANSPOSE();
+TFLMRegistration Register_TRANSPOSE_CONV();
+// TODO(b/230666079): resolve conflict with xtensa implementation
+TFLMRegistration Register_UNIDIRECTIONAL_SEQUENCE_LSTM();
+TFLMRegistration Register_UNPACK();
+TFLMRegistration Register_VAR_HANDLE();
+TFLMRegistration Register_WHILE();
+TFLMRegistration Register_ZEROS_LIKE();
+
+// TODO(b/295174388): Add the rest of inference only registration functions.
+TFLMInferenceRegistration RegisterInference_FULLY_CONNECTED();
+
+// TODO(b/160234179): Change custom OPs to also return by value.
+namespace tflm_signal {
+TFLMRegistration* Register_DELAY();
+TFLMRegistration* Register_FFT_AUTO_SCALE();
+TFLMRegistration* Register_FILTER_BANK();
+TFLMRegistration* Register_FILTER_BANK_LOG();
+TFLMRegistration* Register_FILTER_BANK_SPECTRAL_SUBTRACTION();
+TFLMRegistration* Register_FILTER_BANK_SQUARE_ROOT();
+TFLMRegistration* Register_ENERGY();
+TFLMRegistration* Register_FRAMER();
+TFLMRegistration* Register_OVERLAP_ADD();
+TFLMRegistration* Register_PCAN();
+TFLMRegistration* Register_STACKER();
+TFLMRegistration* Register_WINDOW();
+}  // namespace tflm_signal
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_MICRO_OPS_H_

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

@@ -0,0 +1,56 @@
+/* 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.
+==============================================================================*/
+
+// This file and the associated .cc file is branched from
+// tensorflow/lite/kernels/internal/reference/portable_tensor_utils*
+// TFLM needs to create its own because the original files are coupled with
+// the tensor_utils module, which we cannot reuse due to its use of the
+// Eigen library.
+
+#ifndef TENSORFLOW_LITE_MICRO_KERNELS_MICRO_TENSOR_UTILS_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_MICRO_TENSOR_UTILS_H_
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+
+#include "tensorflow/lite/c/builtin_op_data.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/portable_tensor_utils.h"
+
+#if defined(_MSC_VER)
+#define __restrict__ __restrict
+#endif
+
+namespace tflite_micro {
+
+// Not all backends support CpuBackendContext usage, so forward declare to avoid
+// pulling in its implementation.
+// TODO(b/230666277): consider removing this since micro does not utilize it
+class CpuBackendContext;
+
+// Apply sigmoid to elements of a vector.
+void PortableApplySigmoidToVector(const float* vector, int v_size,
+                                  float* result);
+// Apply tanh to elements of a vector
+void PortableApplyTanhToVector(const float* vector, int v_size, float* result);
+// Apply appropriate activation function to elements of a vector.
+void PortableApplyActivationToVector(const float* vector, int v_size,
+                                     TfLiteFusedActivation activation,
+                                     float* result);
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_MICRO_TENSOR_UTILS_H_

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

@@ -0,0 +1,74 @@
+/* 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_MUL_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_MUL_H_
+
+#include <cstdint>
+
+#include "tensorflow/lite/c/builtin_op_data.h"
+#include "tensorflow/lite/micro/micro_common.h"
+
+namespace tflite_micro {
+
+extern const int kMulInput1Tensor;
+extern const int kMulInput2Tensor;
+extern const int kMulOutputTensor;
+
+struct OpDataMul {
+  int32_t input1_zero_point;
+  int32_t input2_zero_point;
+
+  int32_t output_activation_min;
+  int32_t output_activation_max;
+  int32_t output_zero_point;
+  int32_t output_multiplier;
+  int output_shift;
+
+  float output_activation_min_f32;
+  float output_activation_max_f32;
+};
+
+void* MulInit(TfLiteContext* context, const char* buffer, size_t length);
+
+TfLiteStatus CalculateOpDataMul(TfLiteContext* context, TfLiteNode* node,
+                                TfLiteMulParams* params, OpDataMul* data);
+
+TfLiteStatus MulPrepare(TfLiteContext* context, TfLiteNode* node);
+
+TfLiteStatus EvalMulQuantizedReference(TfLiteContext* context, TfLiteNode* node,
+                                       const OpDataMul* data,
+                                       const TfLiteEvalTensor* input1,
+                                       const TfLiteEvalTensor* input2,
+                                       TfLiteEvalTensor* output);
+
+void EvalMulFloatReference(TfLiteContext* context, TfLiteNode* node,
+                           TfLiteMulParams* params, const OpDataMul* data,
+                           const TfLiteEvalTensor* input1,
+                           const TfLiteEvalTensor* input2,
+                           TfLiteEvalTensor* output);
+
+// Generic must define registration function.
+TFLMRegistration Register_MUL();
+
+#if defined(CMSIS_NN)
+TFLMRegistration Register_MUL_INT8();
+#else
+// Fallback registration
+inline TFLMRegistration Register_MUL_INT8() { return Register_MUL(); }
+#endif
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_MUL_H_

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

@@ -0,0 +1,27 @@
+/* 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_PAD_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_PAD_H_
+
+#include "tensorflow/lite/c/common.h"
+
+namespace tflite_micro {
+
+TfLiteStatus PadPrepare(TfLiteContext* context, TfLiteNode* node);
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_PAD_H_

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

@@ -0,0 +1,142 @@
+/* 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_KERNELS_POOLING_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_POOLING_H_
+
+#include <cstdint>
+
+#include "tensorflow/lite/c/builtin_op_data.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/reference/integer_ops/pooling.h"
+#include "tensorflow/lite/kernels/internal/reference/pooling.h"
+#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
+#include "tensorflow/lite/kernels/kernel_util.h"
+#include "tensorflow/lite/kernels/padding.h"
+#include "tensorflow/lite/micro/kernels/kernel_util.h"
+#include "tensorflow/lite/micro/kernels/micro_ops.h"
+#include "tensorflow/lite/micro/micro_log.h"
+
+namespace tflite_micro {
+
+extern const int kPoolingInputTensor;
+extern const int kPoolingOutputTensor;
+
+struct OpDataPooling {
+  TfLitePaddingValues padding;
+  int32_t activation_min;
+  int32_t activation_max;
+  float activation_min_f32;
+  float activation_max_f32;
+};
+
+TfLiteStatus CalculateOpDataPooling(const TfLiteContext* context,
+                                    const TfLitePoolParams* params,
+                                    const TfLiteTensor* input,
+                                    const TfLiteTensor* output,
+                                    OpDataPooling* data);
+
+TfLiteStatus PoolingPrepare(TfLiteContext* context, TfLiteNode* node);
+
+void AveragePoolingEvalFloat(const TfLiteContext* context,
+                             const TfLiteNode* node,
+                             const TfLitePoolParams* params,
+                             const OpDataPooling* data,
+                             const TfLiteEvalTensor* input,
+                             TfLiteEvalTensor* output);
+
+template <typename T>
+void AveragePoolingEvalQuantized(TfLiteContext* context, const TfLiteNode* node,
+                                 const TfLitePoolParams* params,
+                                 const OpDataPooling* data,
+                                 const TfLiteEvalTensor* input,
+                                 TfLiteEvalTensor* output) {
+  TFLITE_DCHECK(input->type == kTfLiteInt8 || input->type == kTfLiteInt16);
+
+  PoolParams op_params;
+  op_params.stride_height = params->stride_height;
+  op_params.stride_width = params->stride_width;
+  op_params.filter_height = params->filter_height;
+  op_params.filter_width = params->filter_width;
+  op_params.padding_values.height = data->padding.height;
+  op_params.padding_values.width = data->padding.width;
+  op_params.quantized_activation_min = data->activation_min;
+  op_params.quantized_activation_max = data->activation_max;
+
+  reference_integer_ops::AveragePool(op_params,
+                                     tflite_micro::micro::GetTensorShape(input),
+                                     tflite_micro::micro::GetTensorData<T>(input),
+                                     tflite_micro::micro::GetTensorShape(output),
+                                     tflite_micro::micro::GetTensorData<T>(output));
+}
+
+void MaxPoolingEvalFloat(TfLiteContext* context, TfLiteNode* node,
+                         TfLitePoolParams* params, const OpDataPooling* data,
+                         const TfLiteEvalTensor* input,
+                         TfLiteEvalTensor* output);
+
+template <typename T>
+void MaxPoolingEvalQuantized(TfLiteContext* context, TfLiteNode* node,
+                             TfLitePoolParams* params,
+                             const OpDataPooling* data,
+                             const TfLiteEvalTensor* input,
+                             TfLiteEvalTensor* output) {
+  TFLITE_DCHECK(input->type == kTfLiteInt8 || input->type == kTfLiteInt16);
+
+  tflite_micro::PoolParams op_params;
+  op_params.stride_height = params->stride_height;
+  op_params.stride_width = params->stride_width;
+  op_params.filter_height = params->filter_height;
+  op_params.filter_width = params->filter_width;
+  op_params.padding_values.height = data->padding.height;
+  op_params.padding_values.width = data->padding.width;
+  op_params.quantized_activation_min = data->activation_min;
+  op_params.quantized_activation_max = data->activation_max;
+
+  reference_integer_ops::MaxPool(op_params,
+                                 tflite_micro::micro::GetTensorShape(input),
+                                 tflite_micro::micro::GetTensorData<T>(input),
+                                 tflite_micro::micro::GetTensorShape(output),
+                                 tflite_micro::micro::GetTensorData<T>(output));
+}
+
+#if defined(CMSIS_NN) || defined(XTENSA)
+TFLMRegistration Register_AVERAGE_POOL_2D_INT8();
+
+TFLMRegistration Register_MAX_POOL_2D_INT8();
+
+TFLMRegistration Register_AVERAGE_POOL_2D_INT16();
+
+TFLMRegistration Register_MAX_POOL_2D_INT16();
+#else
+inline TFLMRegistration Register_AVERAGE_POOL_2D_INT8() {
+  return tflite_micro::Register_AVERAGE_POOL_2D();
+}
+
+inline TFLMRegistration Register_MAX_POOL_2D_INT8() {
+  return tflite_micro::Register_MAX_POOL_2D();
+}
+
+inline TFLMRegistration Register_AVERAGE_POOL_2D_INT16() {
+  return tflite_micro::Register_AVERAGE_POOL_2D();
+}
+
+inline TFLMRegistration Register_MAX_POOL_2D_INT16() {
+  return tflite_micro::Register_MAX_POOL_2D();
+}
+#endif
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_POOLING_H_

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

@@ -0,0 +1,39 @@
+/* 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_PRELU_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_PRELU_H_
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/types.h"
+
+namespace tflite_micro {
+
+TfLiteStatus CalculatePreluParams(const TfLiteTensor* input,
+                                  const TfLiteTensor* alpha,
+                                  TfLiteTensor* output, PreluParams* params);
+
+void BroadcastPrelu4DSlowFloat(const RuntimeShape& unextended_input1_shape,
+                               const float* input1_data,
+                               const RuntimeShape& unextended_input2_shape,
+                               const float* input2_data,
+                               const RuntimeShape& unextended_output_shape,
+                               float* output_data);
+
+TfLiteStatus PreluPrepare(TfLiteContext* context, TfLiteNode* node);
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_PRELU_H_

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

@@ -0,0 +1,37 @@
+/* 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_QUANTIZE_H_
+#define TENSORFLOW_LITE_MICRO_KERNELS_QUANTIZE_H_
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/types.h"
+
+namespace tflite_micro {
+
+struct OpDataQuantizeReference {
+  tflite_micro::QuantizationParams quantization_params;
+  // The scaling factor from input to output (aka the 'real multiplier') can
+  // be represented as a fixed point multiplier plus a left shift.
+  int32_t requantize_output_multiplier;
+  int requantize_output_shift;
+
+  int32_t input_zero_point;
+};
+
+TfLiteStatus EvalQuantizeReference(TfLiteContext* context, TfLiteNode* node);
+TfLiteStatus PrepareQuantizeReference(TfLiteContext* context, TfLiteNode* node);
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_KERNELS_QUANTIZE_H_