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

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/reference/transpose.h

@@ -0,0 +1,203 @@
+/* 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_KERNELS_INTERNAL_REFERENCE_TRANSPOSE_H_
+#define TENSORFLOW_LITE_KERNELS_INTERNAL_REFERENCE_TRANSPOSE_H_
+
+#include <array>
+
+#include "tensorflow/lite/kernels/internal/types.h"
+
+namespace tflite_micro {
+
+namespace reference_ops {
+
+namespace transpose_internal {
+
+// Recursively explores all the dimensions of the output tensor and writes the
+// corresponding input tensor data.
+//
+// - depth: the current depth of the recursion.
+// - dims: tensor dimension count, also `perm` size.
+// - perm: permutation array.
+// - input_data: Running input data pointer. If depth == num_dims-1, this points
+//               to the first element of the last dimension to traverse.
+// - input_stride: Reverse partial product of input shapes.
+// - output_data: Running output data pointer. If depth == num_dims-1, this
+//                points to the first element of the last dimension to traverse.
+// - output_stride: Reverse partial product of output shapes.
+// - output_shape: Shape of the output tensor.
+//
+// ## Algorithm explanation
+//
+// Assume a 3D tensor T with a shape of [I, J, K] stored in row major order.
+// T[i, j, k] is at position `i*J*K + j*K + k` in the tensor buffer.
+//
+// If we want to go through the whole tensor iteratively, we can use loops.
+//
+// ```
+// for(i = 0; i < I; ++i) {
+//   for(j = 0; j < J; ++j) {
+//     for(k = 0; k < K; ++k) {
+//        T.data[i*J*K + j*K + k] = ...
+//     }
+//   }
+// }
+// ```
+//
+// We can also compute the offset as we go through the loops.
+//
+// ```
+// stride_i = K * J;
+// stride_j = K;
+// stride_k = 1;
+// for(i = 0; i < I; ++i) {
+//   offset_i = i * stride_i;
+//   offset_j = 0;
+//   for(j = 0; j < J; ++j) {
+//     offset_j += stride_j;
+//     offset_k = 0;
+//     for(k = 0; k < K; ++k) {
+//        offset_k += stride_k;
+//        T.data[offset_i + offset_j + offset_k] = ...
+//     }
+//   }
+// }
+// ```
+//
+// This nicely extends to a recursive version which is the base of this
+// algorithm and supports any number of dimensions.
+//
+// ```
+// shape = [I, J, K]
+// strides = [K*J, K, 1]
+// void recurse(T* data, shape, strides, depth = 0) {
+//   if(depth == shape.size) {
+//     *data = ...
+//   } else {
+//     for(a = 0; a < shape[depth]; ++a) {
+//       recurse(data, shape, strides, depth+1);
+//       data += strides[depth];
+//     }
+//   }
+// }
+// ```
+template <typename T>
+void TransposeImpl(const int depth, const int dims, const int32_t* perm,
+                   const T* input_data, const int* input_stride, T* output_data,
+                   const int* output_stride, const int32_t* output_shape) {
+  const int dimension_size = output_shape[depth];
+  if (depth == dims - 1) {
+    const int loop_stride = input_stride[perm[depth]];
+    for (int i = 0; i < dimension_size; ++i) {
+      output_data[i] = *input_data;
+      input_data += loop_stride;
+    }
+  } else {
+    for (int i = 0; i < dimension_size; ++i) {
+      TransposeImpl(depth + 1, dims, perm, input_data, input_stride,
+                    output_data, output_stride, output_shape);
+
+      input_data += input_stride[perm[depth]];
+      output_data += output_stride[depth];
+    }
+  }
+}
+
+// Compile-time switch to get the storage type of the transposition.
+template <int Size>
+struct TransposeStorageType;
+
+template <>
+struct TransposeStorageType<1> {
+  using type = int8_t;
+};
+
+template <>
+struct TransposeStorageType<2> {
+  using type = int16_t;
+};
+
+template <>
+struct TransposeStorageType<4> {
+  using type = int32_t;
+};
+
+template <>
+struct TransposeStorageType<8> {
+  using type = int64_t;
+};
+
+// Sets up the stride arrays for the recursive transpose algorithm.
+//
+// Implementation notes:
+//
+// This is a reverse partial product. We could use standard algorithms to
+// implement this but the result is not a readable and is tricky to get right
+// because the first element must be set to 1, which leads to offset
+// shenanigans:
+//
+// ```
+//   stride[dims - 1] = 1;
+//   std::partial_sum(std::make_reverse_iterator(shape + dims),
+//                    std::make_reverse_iterator(shape + 1),
+//                    stride.rend() - input_rank + 1, std::multiplies());
+// ```
+//
+// Note that Abseil isn't used in kernels implementation. That would make the
+// above solution more readable.
+inline void SetupTransposeStrides(
+    std::array<int, kTransposeMaxDimensions>& stride, const int32_t* shape,
+    const int dims) {
+  stride[dims - 1] = 1;
+  for (int i = dims - 2; i >= 0; --i) {
+    stride[i] = stride[i + 1] * shape[i + 1];
+  }
+}
+
+}  // namespace transpose_internal
+
+// Copies a tensor to an other buffer and permutes its dimensions.
+//
+// Note: template parameter N is not used anymore. It is kept for API
+// compatibility with TFLite micro.
+template <typename T, int N = kTransposeMaxDimensions>
+void Transpose(const TransposeParams& params, const RuntimeShape& input_shape,
+               const T* input_data, const RuntimeShape& output_shape,
+               T* output_data) {
+  using transpose_internal::SetupTransposeStrides;
+  using transpose_internal::TransposeImpl;
+  using transpose_internal::TransposeStorageType;
+  // Transpose kernel only does rearranging values not numeric evaluations on
+  // each cell. It's safe to implement per size of scalar type and this trick
+  // keeps the total code size in a reasonable range.
+  using StorageType = typename TransposeStorageType<sizeof(T)>::type;
+  const StorageType* const input_data_storage =
+      reinterpret_cast<const StorageType*>(input_data);
+  StorageType* const output_data_storage =
+      reinterpret_cast<StorageType*>(output_data);
+
+  const int dims = input_shape.DimensionsCount();
+  std::array<int, kTransposeMaxDimensions> input_stride, output_stride;
+  SetupTransposeStrides(input_stride, input_shape.DimsData(), dims);
+  SetupTransposeStrides(output_stride, output_shape.DimsData(), dims);
+  TransposeImpl(0, dims, &params.perm[0], input_data_storage,
+                input_stride.data(), output_data_storage, output_stride.data(),
+                output_shape.DimsData());
+}
+
+}  // namespace reference_ops
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_REFERENCE_TRANSPOSE_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/reference/transpose_conv.h

@@ -0,0 +1,225 @@
+/* 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_KERNELS_INTERNAL_REFERENCE_TRANSPOSE_CONV_H_
+#define TENSORFLOW_LITE_KERNELS_INTERNAL_REFERENCE_TRANSPOSE_CONV_H_
+
+#include <algorithm>
+
+#include "tensorflow/lite/kernels/internal/common.h"
+#include "tensorflow/lite/kernels/internal/types.h"
+
+namespace tflite_micro {
+
+namespace reference_ops {
+
+inline void TransposeConv(
+    const ConvParams& params, const RuntimeShape& input_shape,
+    const float* input_data, const RuntimeShape& filter_shape,
+    const float* filter_data, const RuntimeShape& bias_shape,
+    const float* bias_data, const RuntimeShape& output_shape,
+    float* output_data, const RuntimeShape& im2col_shape, float* im2col_data) {
+  const int stride_width = params.stride_width;
+  const int stride_height = params.stride_height;
+  const int pad_width = params.padding_values.width;
+  const int pad_height = params.padding_values.height;
+  TFLITE_DCHECK_EQ(input_shape.DimensionsCount(), 4);
+  TFLITE_DCHECK_EQ(filter_shape.DimensionsCount(), 4);
+  TFLITE_DCHECK_EQ(output_shape.DimensionsCount(), 4);
+  (void)im2col_data;   // only used in optimized code.
+  (void)im2col_shape;  // only used in optimized code.
+
+  const int batches = MatchingDim(input_shape, 0, output_shape, 0);
+  const int input_depth = MatchingDim(input_shape, 3, filter_shape, 3);
+  const int output_depth = MatchingDim(filter_shape, 0, output_shape, 3);
+  const int input_height = input_shape.Dims(1);
+  const int input_width = input_shape.Dims(2);
+  const int filter_height = filter_shape.Dims(1);
+  const int filter_width = filter_shape.Dims(2);
+  const int output_height = output_shape.Dims(1);
+  const int output_width = output_shape.Dims(2);
+  const float output_activation_min = params.float_activation_min;
+  const float output_activation_max = params.float_activation_max;
+  if (bias_data) {
+    TFLITE_DCHECK_EQ(bias_shape.FlatSize(), output_depth);
+  }
+
+  // Although transpose convolution simplifies to convolution with transposed
+  // weights for strides of 1, non-unitary striding complicates matters. To
+  // keep this reference implementation as clear as possible, we use a
+  // "scatter" access pattern, where we loop through all the input elements,
+  // computing their influence on the output, rather than looping through the
+  // output elements in the typical "gather" access pattern of a conv. We
+  // therefore must initialize the output array to zero.
+  const int num_elements = output_shape.FlatSize();
+  for (int i = 0; i < num_elements; i++) {
+    output_data[i] = 0.0f;
+  }
+
+  // Loop through input elements one at a time.
+  for (int batch = 0; batch < batches; ++batch) {
+    for (int in_y = 0; in_y < input_height; ++in_y) {
+      for (int in_x = 0; in_x < input_width; ++in_x) {
+        for (int in_channel = 0; in_channel < input_depth; ++in_channel) {
+          // Loop through the output elements it will influence
+          const int out_x_origin = (in_x * stride_width) - pad_width;
+          const int out_y_origin = (in_y * stride_height) - pad_height;
+          for (int filter_y = 0; filter_y < filter_height; ++filter_y) {
+            for (int filter_x = 0; filter_x < filter_width; ++filter_x) {
+              for (int out_channel = 0; out_channel < output_depth;
+                   ++out_channel) {
+                // Compute output element location
+                const int out_x = out_x_origin + filter_x;
+                const int out_y = out_y_origin + filter_y;
+                // We cannot accumulate out of bounds
+                if ((out_x >= 0) && (out_x < output_width) && (out_y >= 0) &&
+                    (out_y < output_height)) {
+                  float input_value = input_data[Offset(
+                      input_shape, batch, in_y, in_x, in_channel)];
+                  float filter_value =
+                      filter_data[Offset(filter_shape, out_channel, filter_y,
+                                         filter_x, in_channel)];
+                  output_data[Offset(output_shape, batch, out_y, out_x,
+                                     out_channel)] +=
+                      input_value * filter_value;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (int batch = 0; batch < batches; ++batch) {
+    for (int out_y = 0; out_y < output_height; ++out_y) {
+      for (int out_x = 0; out_x < output_width; ++out_x) {
+        for (int out_channel = 0; out_channel < output_depth; ++out_channel) {
+          float acc = output_data[Offset(output_shape, batch, out_y, out_x,
+                                         out_channel)];
+          if (bias_data) acc += bias_data[out_channel];
+
+          output_data[Offset(output_shape, batch, out_y, out_x, out_channel)] =
+              ActivationFunctionWithMinMax(acc, output_activation_min,
+                                           output_activation_max);
+        }
+      }
+    }
+  }
+}
+
+inline void TransposeConv(
+    const ConvParams& params, const RuntimeShape& input_shape,
+    const uint8_t* input_data, const RuntimeShape& filter_shape,
+    const uint8_t* filter_data, const RuntimeShape& bias_shape,
+    const int32_t* bias_data, const RuntimeShape& output_shape,
+    uint8_t* output_data, const RuntimeShape& im2col_shape,
+    uint8_t* im2col_data, int32_t* scratch_buffer) {
+  const int stride_width = params.stride_width;
+  const int stride_height = params.stride_height;
+  const int pad_width = params.padding_values.width;
+  const int pad_height = params.padding_values.height;
+  TFLITE_DCHECK_EQ(input_shape.DimensionsCount(), 4);
+  TFLITE_DCHECK_EQ(filter_shape.DimensionsCount(), 4);
+  TFLITE_DCHECK_EQ(output_shape.DimensionsCount(), 4);
+  (void)im2col_data;   // only used in optimized code.
+  (void)im2col_shape;  // only used in optimized code.
+
+  const int batches = MatchingDim(input_shape, 0, output_shape, 0);
+  const int input_depth = MatchingDim(input_shape, 3, filter_shape, 3);
+  const int output_depth = MatchingDim(filter_shape, 0, output_shape, 3);
+  const int input_height = input_shape.Dims(1);
+  const int input_width = input_shape.Dims(2);
+  const int filter_height = filter_shape.Dims(1);
+  const int filter_width = filter_shape.Dims(2);
+  const int output_height = output_shape.Dims(1);
+  const int output_width = output_shape.Dims(2);
+  const int32_t input_offset = params.input_offset;
+  const int32_t filter_offset = params.weights_offset;
+  const int32_t output_offset = params.output_offset;
+  const int32_t output_multiplier = params.output_multiplier;
+  const int output_shift = params.output_shift;
+  const int32_t output_activation_min = params.quantized_activation_min;
+  const int32_t output_activation_max = params.quantized_activation_max;
+  TFLITE_DCHECK_LE(output_activation_min, output_activation_max);
+  if (bias_data) {
+    TFLITE_DCHECK_EQ(bias_shape.FlatSize(), output_depth);
+  }
+
+  const int num_elements = output_shape.FlatSize();
+  // We need to initialize scratch_buffer to all 0s, as we apply the same
+  // 'scatter' based trick as in float version.
+  memset(scratch_buffer, 0, num_elements * sizeof(int32_t));
+
+  // Loop through input elements one at a time.
+  for (int batch = 0; batch < batches; ++batch) {
+    for (int in_y = 0; in_y < input_height; ++in_y) {
+      for (int in_x = 0; in_x < input_width; ++in_x) {
+        for (int in_channel = 0; in_channel < input_depth; ++in_channel) {
+          // Loop through the output elements it will influence.
+          const int out_x_origin = (in_x * stride_width) - pad_width;
+          const int out_y_origin = (in_y * stride_height) - pad_height;
+          for (int filter_y = 0; filter_y < filter_height; ++filter_y) {
+            for (int filter_x = 0; filter_x < filter_width; ++filter_x) {
+              for (int out_channel = 0; out_channel < output_depth;
+                   ++out_channel) {
+                // Compute output element location.
+                const int out_x = out_x_origin + filter_x;
+                const int out_y = out_y_origin + filter_y;
+                // We cannot accumulate out of bounds.
+                if ((out_x >= 0) && (out_x < output_width) && (out_y >= 0) &&
+                    (out_y < output_height)) {
+                  uint8_t input_value = input_data[Offset(
+                      input_shape, batch, in_y, in_x, in_channel)];
+                  uint8_t filter_value =
+                      filter_data[Offset(filter_shape, out_channel, filter_y,
+                                         filter_x, in_channel)];
+                  scratch_buffer[Offset(output_shape, batch, out_y, out_x,
+                                        out_channel)] +=
+                      (input_value + input_offset) *
+                      (filter_value + filter_offset);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  for (int batch = 0; batch < batches; ++batch) {
+    for (int out_y = 0; out_y < output_height; ++out_y) {
+      for (int out_x = 0; out_x < output_width; ++out_x) {
+        for (int out_channel = 0; out_channel < output_depth; ++out_channel) {
+          int32_t acc = scratch_buffer[Offset(output_shape, batch, out_y, out_x,
+                                              out_channel)];
+          if (bias_data) {
+            acc += bias_data[out_channel];
+          }
+          int32_t scaled_acc = MultiplyByQuantizedMultiplier(
+              acc, output_multiplier, output_shift);
+          scaled_acc += output_offset;
+          scaled_acc = std::max(scaled_acc, output_activation_min);
+          scaled_acc = std::min(scaled_acc, output_activation_max);
+          output_data[Offset(output_shape, batch, out_y, out_x, out_channel)] =
+              static_cast<uint8_t>(scaled_acc);
+        }
+      }
+    }
+  }
+}
+
+}  // namespace reference_ops
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_REFERENCE_TRANSPOSE_CONV_H_

xmos_ai_tools/runtime/include/tensorflow/lite/kernels/internal/runtime_shape.h

@@ -0,0 +1,168 @@
+/* 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_KERNELS_INTERNAL_RUNTIME_SHAPE_H_
+#define TENSORFLOW_LITE_KERNELS_INTERNAL_RUNTIME_SHAPE_H_
+
+#include <cstring>
+
+#include "tensorflow/lite/kernels/internal/compatibility.h"
+
+namespace tflite_micro {
+
+template <int N>
+struct Dims {
+  int sizes[N];
+  int strides[N];
+};
+
+class RuntimeShape {
+ public:
+  RuntimeShape& operator=(RuntimeShape const&) = delete;
+
+  // RuntimeShape in TFLM supports up to 6 dimensions.
+  // The name kMaxSmallSize comes from the same file of the upstream
+  // tensorflow lite repo and need to be kept the same for max reuse.
+  static constexpr int kMaxSmallSize = 6;
+
+  RuntimeShape() : size_(0) {}
+
+  explicit RuntimeShape(int dimensions_count) : size_(dimensions_count) {
+    TFLITE_DCHECK_LE(dimensions_count, kMaxSmallSize);
+  }
+
+  RuntimeShape(int shape_size, int32_t value) : size_(shape_size) {
+    TFLITE_DCHECK_LE(shape_size, kMaxSmallSize);
+    for (int i = 0; i < shape_size; ++i) {
+      SetDim(i, value);
+    }
+  }
+
+  RuntimeShape(int dimensions_count, const int32_t* dims_data)
+      : size_(dimensions_count) {
+    // check of dimensions_count handled by ReplaceWith()
+    ReplaceWith(dimensions_count, dims_data);
+  }
+
+  bool operator==(const RuntimeShape& comp) const {
+    return this->size_ == comp.size_ &&
+           std::memcmp(DimsData(), comp.DimsData(), size_ * sizeof(int32_t)) ==
+               0;
+  }
+
+  ~RuntimeShape() {}
+
+  int32_t DimensionsCount() const { return size_; }
+  int32_t Dims(int i) const {
+    TFLITE_DCHECK_GE(i, 0);
+    TFLITE_DCHECK_LT(i, size_);
+    return dims_[i];
+  }
+  void SetDim(int i, int32_t val) {
+    TFLITE_DCHECK_GE(i, 0);
+    TFLITE_DCHECK_LT(i, size_);
+    dims_[i] = val;
+  }
+
+  static RuntimeShape ExtendedShape(int new_shape_size,
+                                    const RuntimeShape& shape) {
+    TFLITE_DCHECK_LE(new_shape_size, kMaxSmallSize);
+    return RuntimeShape(new_shape_size, shape, 1);
+  }
+  int32_t* DimsData() { return dims_; }
+  const int32_t* DimsData() const { return dims_; }
+  const int32_t* DimsDataUpTo5D() const { return dims_; }
+
+  void ReplaceWith(int dimensions_count, const int32_t* dims_data) {
+    TFLITE_DCHECK_LE(dimensions_count, kMaxSmallSize);
+    size_ = dimensions_count;
+    int32_t* dst_dims = DimsData();
+    std::memcpy(dst_dims, dims_data, dimensions_count * sizeof(int32_t));
+  }
+
+  // Returns the total count of elements, that is the size when flattened into a
+  // vector.
+  int FlatSize() const {
+    int buffer_size = 1;
+    const int* dims_data = reinterpret_cast<const int*>(DimsData());
+    for (int i = 0; i < size_; i++) {
+      buffer_size *= dims_data[i];
+    }
+    return buffer_size;
+  }
+
+ private:
+  // For use only by ExtendedShape(), written to guarantee (return-value) copy
+  // elision in C++17.
+  // This creates a shape padded to the desired size with the specified value.
+  RuntimeShape(int new_shape_size, const RuntimeShape& shape, int pad_value)
+      : size_(new_shape_size) {
+    // If the following check fails, it is likely because a 4D-only kernel is
+    // being used with an array of larger dimension count.
+    TFLITE_CHECK_GE(new_shape_size, shape.DimensionsCount());
+    const int size_increase = new_shape_size - shape.DimensionsCount();
+    for (int i = 0; i < size_increase; ++i) {
+      SetDim(i, pad_value);
+    }
+    std::memcpy(DimsData() + size_increase, shape.DimsData(),
+                sizeof(int32_t) * shape.DimensionsCount());
+  }
+
+  int32_t size_;
+  union {
+    int32_t dims_[kMaxSmallSize];
+  };
+};
+
+// Since tensors with '0' in their shape are valid in TF, these offset functions
+// allow that as long as the corresponding index is also 0. It is upto the
+// calling ops to ensure that they perform verification checks on tensor shapes
+// if they don't support a particular behavior.
+
+inline int Offset(const RuntimeShape& shape, int i0, int i1, int i2, int i3) {
+  TFLITE_DCHECK_EQ(shape.DimensionsCount(), 4);
+  const int* dims_data = reinterpret_cast<const int*>(shape.DimsData());
+  TFLITE_DCHECK((dims_data[0] == 0 && i0 == 0) ||
+                (i0 >= 0 && i0 < dims_data[0]));
+  TFLITE_DCHECK((dims_data[1] == 0 && i1 == 0) ||
+                (i1 >= 0 && i1 < dims_data[1]));
+  TFLITE_DCHECK((dims_data[2] == 0 && i2 == 0) ||
+                (i2 >= 0 && i2 < dims_data[2]));
+  TFLITE_DCHECK((dims_data[3] == 0 && i3 == 0) ||
+                (i3 >= 0 && i3 < dims_data[3]));
+  return ((i0 * dims_data[1] + i1) * dims_data[2] + i2) * dims_data[3] + i3;
+}
+
+inline int Offset(const RuntimeShape& shape, int i0, int i1, int i2, int i3,
+                  int i4) {
+  TFLITE_DCHECK_EQ(shape.DimensionsCount(), 5);
+  const int* dims_data = reinterpret_cast<const int*>(shape.DimsData());
+  TFLITE_DCHECK((dims_data[0] == 0 && i0 == 0) ||
+                (i0 >= 0 && i0 < dims_data[0]));
+  TFLITE_DCHECK((dims_data[1] == 0 && i1 == 0) ||
+                (i1 >= 0 && i1 < dims_data[1]));
+  TFLITE_DCHECK((dims_data[2] == 0 && i2 == 0) ||
+                (i2 >= 0 && i2 < dims_data[2]));
+  TFLITE_DCHECK((dims_data[3] == 0 && i3 == 0) ||
+                (i3 >= 0 && i3 < dims_data[3]));
+  TFLITE_DCHECK((dims_data[4] == 0 && i4 == 0) ||
+                (i4 >= 0 && i4 < dims_data[4]));
+  return (((i0 * dims_data[1] + i1) * dims_data[2] + i2) * dims_data[3] + i3) *
+             dims_data[4] +
+         i4;
+}
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_KERNELS_INTERNAL_RUNTIME_SHAPE_H_