xmos-ai-tools 1.2.1.dev20__py3-none-win_amd64.whl → 1.3.2.dev180__py3-none-win_amd64.whl

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

@@ -25,7 +25,7 @@ limitations under the License.
 
 #define KRNL_C_DIM_NHWC 0  // output channels
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 
@@ -118,7 +118,7 @@ inline void MliTensorAttachBuffer<int8_t>(const TfLiteEvalTensor* tfT,
   // non-const mli_tensor. This is required by current implementation of MLI
   // backend and planned for redesign due to this and some other aspects.
   mliT->SetData<int8_t>(
-      const_cast<int8_t*>(tflite::micro::GetTensorData<int8_t>(tfT)),
+      const_cast<int8_t*>(tflite_micro::micro::GetTensorData<int8_t>(tfT)),
       *mliT->DataCapacity());
 }
 
@@ -129,7 +129,7 @@ inline void MliTensorAttachBuffer<int32_t>(const TfLiteEvalTensor* tfT,
   // non-const mli_tensor. This is required by current implementation of MLI
   // backend and planned for redesign due to this and some other aspects.
   mliT->SetData<int32_t>(
-      const_cast<int32_t*>(tflite::micro::GetTensorData<int32_t>(tfT)),
+      const_cast<int32_t*>(tflite_micro::micro::GetTensorData<int32_t>(tfT)),
       *mliT->DataCapacity());
 }
 
@@ -305,6 +305,6 @@ inline void permute_weights(const mli_tensor* weights_src,
 
 }  // namespace micro
 }  // namespace ops
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_ARC_MLI_TF_UTILS_H_

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

@@ -20,7 +20,7 @@ limitations under the License.
 #include "mli_interface.h"
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 
@@ -140,6 +140,6 @@ TfLiteStatus arc_scratch_buffer_calc_slice_size_weights(
 
 }  // namespace micro
 }  // namespace ops
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_ARC_SCRATCH_BUF_MGR_H_

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

@@ -19,7 +19,7 @@ limitations under the License.
 #include "mli_api.h"  // NOLINT
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace ops {
 namespace micro {
 
@@ -73,6 +73,6 @@ static inline bool inside_arc_ccm(void* p) {
 
 }  // namespace micro
 }  // namespace ops
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_ARC_SCRATCH_BUFFERS_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/kernels/ceva/types.h

@@ -209,7 +209,7 @@ inline bool NextIndex(const int num_dims, const int* dims, int* current) {
 
 #include "tensorflow/lite/kernels/internal/compatibility.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 enum class FusedActivationFunctionType : uint8_t { kNone, kRelu6, kRelu1, kRelu };
 enum class PaddingType : uint8_t { kNone, kSame, kValid };
@@ -485,9 +485,9 @@ class RuntimeShape {
   };
 };
 
-// Converts inference-style shape to legacy tflite::Dims<4>.
-inline tflite::Dims<4> ToRuntimeDims(const tflite::RuntimeShape& array_shape) {
-  tflite::Dims<4> result;
+// Converts inference-style shape to legacy tflite_micro::Dims<4>.
+inline tflite_micro::Dims<4> ToRuntimeDims(const tflite_micro::RuntimeShape& array_shape) {
+  tflite_micro::Dims<4> result;
   const int dimensions_count = array_shape.DimensionsCount();
   TFLITE_CHECK_LE(dimensions_count, 4);
   int cum_prod = 1;
@@ -502,7 +502,7 @@ inline tflite::Dims<4> ToRuntimeDims(const tflite::RuntimeShape& array_shape) {
 }
 
 // TODO(b/80418076): Move to legacy ops file, update invocations.
-inline RuntimeShape DimsToShape(const tflite::Dims<4>& dims) {
+inline RuntimeShape DimsToShape(const tflite_micro::Dims<4>& dims) {
   return RuntimeShape(
       {dims.sizes[3], dims.sizes[2], dims.sizes[1], dims.sizes[0]});
 }
@@ -1281,6 +1281,6 @@ inline void GetActivationParams(const P& params, float* min, float* max) {
   *max = params.float_activation_max;
 }
 
-}  // namespace tflite
+}  // namespace tflite_micro
 #endif
 #endif  // CEVA_TYPES_H_

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

@@ -19,7 +19,7 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // The CircularBuffer op has one input and one output tensor.
 extern const int kCircularBufferInputTensor;
@@ -40,6 +40,6 @@ struct OpDataCircularBuffer {
 
 TfLiteStatus CircularBufferPrepare(TfLiteContext* context, TfLiteNode* node);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_CIRCULAR_BUFFER_H_

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

@@ -22,7 +22,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/types.h"
 #include "tensorflow/lite/micro/micro_common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 struct OpDataConv {
   TfLitePaddingValues padding;
@@ -112,6 +112,6 @@ inline TFLMRegistration Register_CONV_2D_INT8() { return Register_CONV_2D(); }
 inline TFLMRegistration Register_CONV_2D_INT16() { return Register_CONV_2D(); }
 #endif  // defined(CMSIS_NN) || defined(XTENSA)
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_CONV_H_

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

@@ -23,7 +23,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/test_helpers.h"
 #include "tensorflow/lite/micro/testing/micro_test.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace testing {
 
 TfLiteStatus InvokeConv(TfLiteTensor* tensors, int tensors_size,
@@ -89,6 +89,6 @@ TfLiteStatus TestConvQuantizedPerChannel(
     TFLMRegistration registration, int16_t* output_data);
 
 }  // namespace testing
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_CONV_TEST_H_

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

@@ -23,7 +23,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/types.h"
 #include "tensorflow/lite/micro/kernels/conv.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 extern const int kDepthwiseConvInputTensor;
 extern const int kDepthwiseConvWeightsTensor;
@@ -75,6 +75,6 @@ inline TFLMRegistration Register_DEPTHWISE_CONV_2D_INT16() {
 }
 #endif
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_DEPTHWISE_CONV_H_

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

@@ -20,10 +20,10 @@ limitations under the License.
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/types.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 struct DequantizeOpData {
-  tflite::DequantizationParams quantization_params;
+  tflite_micro::DequantizationParams 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 output_multiplier;
@@ -33,6 +33,6 @@ struct DequantizeOpData {
 
 TfLiteStatus DequantizePrepare(TfLiteContext* context, TfLiteNode* node);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_DEQUANTIZE_H_

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

@@ -17,12 +17,12 @@ limitations under the License.
 
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 TFLMRegistration* Register_ETHOSU();
 
 const char* GetString_ETHOSU();
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_ETHOSU_H_

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

@@ -21,7 +21,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/types.h"
 #include "tensorflow/lite/micro/micro_common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 struct OpDataFullyConnected {
   // The scaling factor from input to output (aka the 'real multiplier') can
@@ -107,6 +107,6 @@ inline TFLMRegistration Register_FULLY_CONNECTED_INT16() {
 
 #endif
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_FULLY_CONNECTED_H_

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

@@ -19,12 +19,12 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 extern const int kHardSwishInputTensor;
 extern const int kHardSwishOutputTensor;
 
 TfLiteStatus HardSwishPrepare(TfLiteContext* context, TfLiteNode* node);
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_HARD_SWISH_H_

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

@@ -22,7 +22,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/fake_micro_context.h"
 #include "tensorflow/lite/micro/mock_micro_graph.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace micro {
 
 // Helper class to perform a simulated kernel (i.e. TFLMRegistration)
@@ -81,6 +81,6 @@ class KernelRunner {
 };
 
 }  // namespace micro
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_KERNEL_RUNNER_H_

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

@@ -25,7 +25,7 @@ limitations under the License.
 #include "tensorflow/lite/kernels/internal/types.h"
 #include "tensorflow/lite/micro/micro_context.h"
 
-namespace tflite {
+namespace tflite_micro {
 namespace micro {
 
 TFLMRegistration RegisterOp(
@@ -145,6 +145,6 @@ TfLiteEvalTensor MakeUnpackedInt4Tensor(TfLiteContext* context,
                                         int scratch_buffer_index,
                                         const TfLiteEvalTensor* tensor);
 }  // namespace micro
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_KERNEL_UTIL_H_

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

@@ -18,7 +18,7 @@ limitations under the License.
 
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Input/output tensor index.
 extern const int kInputTensor;
@@ -38,6 +38,6 @@ TfLiteStatus CalculateOpDataLeakyRelu(TfLiteContext* context, TfLiteNode* node);
 
 TfLiteStatus LeakyReluPrepare(TfLiteContext* context, TfLiteNode* node);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_LEAKY_RELU_H_

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

@@ -18,7 +18,7 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 // Input/output tensor index.
 extern const int kLogicalInputTensor1;
 extern const int kLogicalInputTensor2;
@@ -30,6 +30,6 @@ TfLiteStatus LogicalImpl(TfLiteContext* context, TfLiteNode* node,
 bool LogicalOr(bool x, bool y);
 bool LogicalAnd(bool x, bool y);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_LOGICAL_H_

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

@@ -21,7 +21,7 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 
-namespace tflite {
+namespace tflite_micro {
 extern const int kLogisticInputTensor;
 extern const int kLogisticOutputTensor;
 
@@ -38,5 +38,5 @@ TfLiteStatus CalculateArithmeticOpDataLogistic(TfLiteContext* context,
 
 TfLiteStatus LogisticPrepare(TfLiteContext* context, TfLiteNode* node);
 
-}  // namespace tflite
+}  // namespace tflite_micro
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_LOGISTIC_H_

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

@@ -28,7 +28,7 @@ limitations under the License.
 #include "tensorflow/lite/micro/kernels/lstm_shared.h"
 #include "tensorflow/lite/micro/micro_log.h"
 
-namespace tflite {
+namespace tflite_micro {
 
 // Interface to access all the TempTfLiteTensors of the LSTM kernel during the
 // preparation phase. Can only be constructed through the constructor to avoid
@@ -100,7 +100,7 @@ TfLiteStatus CreateGateParams(
     const TfLiteTensor* hidden_state_bias,
     /*Scale of the fc output (input to non-linear activation)*/
     const float nonlinear_activation_input_scale, const TfLiteType cell_type,
-    const tflite::GateParameters& gate_params);
+    const tflite_micro::GateParameters& gate_params);
 
 // Create parameters for element wise multiplication that happens in a) cell
 // state update ; b) hidden state update
@@ -108,7 +108,7 @@ TfLiteStatus CreateGateParams(
 // are required for input. However, during the hidden state update phase, the
 // output is the updated hidden state, which is asymmetrically quantized. Thus
 // output may require zero point
-tflite::ArithmeticParams CreateInterGateMulParams(const float input1_scale,
+tflite_micro::ArithmeticParams CreateInterGateMulParams(const float input1_scale,
                                                   const float input2_scale,
                                                   const float output_scale,
                                                   const TfLiteType output_type,
@@ -121,11 +121,11 @@ CellStateInfo CreateLstmCellStateInfo(const float cell_state_scale,
                                       const float cell_clip);
 
 CellStateInfo CreateLstmCellStateInfoFloat(const float cell_clip);
-tflite::FullyConnectedParams CreateFCParamsFloat();
+tflite_micro::FullyConnectedParams CreateFCParamsFloat();
 
-tflite::GateParameters CreateGateParamsFloat();
+tflite_micro::GateParameters CreateGateParamsFloat();
 
-tflite::ArithmeticParams CreateInterGateMulParamsFloat();
+tflite_micro::ArithmeticParams CreateInterGateMulParamsFloat();
 
 TfLiteStatus PrepareGateParametersFloat(TfLiteContext* context,
                                         const LstmTensors& lstm_tensors,
@@ -267,29 +267,29 @@ void CalculateLstmGate(
   const auto gate_output_shape = step_info.StateShape();
   // Check offset validity to avoid memory overflow
   TFLITE_DCHECK_LE(step_info.InputOffset() + step_info.InputShape().FlatSize(),
-                   tflite::micro::GetTensorShape(input).FlatSize());
+                   tflite_micro::micro::GetTensorShape(input).FlatSize());
   TFLITE_DCHECK_LE(
       step_info.HiddenStateOffset() + step_info.StateShape().FlatSize(),
-      tflite::micro::GetTensorShape(recurrent).FlatSize());
+      tflite_micro::micro::GetTensorShape(recurrent).FlatSize());
 
   // Input FC
   FullyConnected(gate_params.input_fc_params, step_info.InputShape(),
-                 tflite::micro::GetTensorData<ActivationType>(input) +
+                 tflite_micro::micro::GetTensorData<ActivationType>(input) +
                      step_info.InputOffset(),
                  micro::GetTensorShape(input_weight),
-                 tflite::micro::GetTensorData<WeightType>(input_weight),
-                 tflite::micro::GetTensorShape(input_bias),
-                 tflite::micro::GetOptionalTensorData<BiasType>(input_bias),
+                 tflite_micro::micro::GetTensorData<WeightType>(input_weight),
+                 tflite_micro::micro::GetTensorShape(input_bias),
+                 tflite_micro::micro::GetOptionalTensorData<BiasType>(input_bias),
                  gate_output_shape, gate_output);
 
   // Recurrent FC
   FullyConnected(gate_params.recurrent_fc_params, step_info.StateShape(),
-                 tflite::micro::GetTensorData<ActivationType>(recurrent) +
+                 tflite_micro::micro::GetTensorData<ActivationType>(recurrent) +
                      step_info.HiddenStateOffset(),
-                 tflite::micro::GetTensorShape(recurrent_weight),
-                 tflite::micro::GetTensorData<WeightType>(recurrent_weight),
-                 tflite::micro::GetTensorShape(recurrent_bias),
-                 tflite::micro::GetOptionalTensorData<BiasType>(recurrent_bias),
+                 tflite_micro::micro::GetTensorShape(recurrent_weight),
+                 tflite_micro::micro::GetTensorData<WeightType>(recurrent_weight),
+                 tflite_micro::micro::GetTensorShape(recurrent_bias),
+                 tflite_micro::micro::GetOptionalTensorData<BiasType>(recurrent_bias),
                  gate_output_shape, fc_output_buffer);
 
   AddElementWise(gate_output, fc_output_buffer,
@@ -329,31 +329,31 @@ void UpdateLstmCell(const LstmStepManager& step_info,
   // Check offset validity to avoid memory overflow
   TFLITE_DCHECK_LE(
       step_info.CellStateOffset() + step_info.StateShape().FlatSize(),
-      tflite::micro::GetTensorShape(cell_state).FlatSize());
+      tflite_micro::micro::GetTensorShape(cell_state).FlatSize());
 
   auto cell_state_shape = step_info.StateShape();
   // Forget Gate x Cell State
   Mul(cell_state_shape, forget_cell_mul_params, forget_gate_output,
-      tflite::micro::GetTensorData<CellType>(cell_state) +
+      tflite_micro::micro::GetTensorData<CellType>(cell_state) +
           step_info.CellStateOffset(),
-      tflite::micro::GetTensorData<CellType>(cell_state) +
+      tflite_micro::micro::GetTensorData<CellType>(cell_state) +
           step_info.CellStateOffset());
   // Input Gate x Cell Gate
   Mul(cell_state_shape, input_mul_params, input_gate_output, cell_gate_output,
       buffer);
 
   // Update the cell state
-  AddElementWise(tflite::micro::GetTensorData<CellType>(cell_state) +
+  AddElementWise(tflite_micro::micro::GetTensorData<CellType>(cell_state) +
                      step_info.CellStateOffset(),
                  buffer,
                  /*n_batch=*/cell_state_shape.DimsData()[0],
                  /*n_state=*/cell_state_shape.DimsData()[1],
-                 tflite::micro::GetTensorData<CellType>(cell_state) +
+                 tflite_micro::micro::GetTensorData<CellType>(cell_state) +
                      step_info.CellStateOffset());
 
   if (cell_state_info.cell_clip > 0) {
     Clipping(cell_state_shape.FlatSize(), cell_state_info,
-             tflite::micro::GetTensorData<CellType>(cell_state) +
+             tflite_micro::micro::GetTensorData<CellType>(cell_state) +
                  step_info.CellStateOffset());
   }
 }
@@ -371,21 +371,21 @@ void UpdateLstmHidden(const LstmStepManager& step_info,
   // Check offset validity to avoid memory overflow
   TFLITE_DCHECK_LE(
       step_info.CellStateOffset() + step_info.StateShape().FlatSize(),
-      tflite::micro::GetTensorShape(cell_state).FlatSize());
+      tflite_micro::micro::GetTensorShape(cell_state).FlatSize());
   TFLITE_DCHECK_LE(
       step_info.HiddenStateOffset() + step_info.StateShape().FlatSize(),
-      tflite::micro::GetTensorShape(hidden_state).FlatSize());
+      tflite_micro::micro::GetTensorShape(hidden_state).FlatSize());
 
   auto cell_state_shape = step_info.StateShape();
   CellType* cell_state_data =
-      tflite::micro::GetTensorData<CellType>(cell_state) +
+      tflite_micro::micro::GetTensorData<CellType>(cell_state) +
       step_info.CellStateOffset();
   // Tanh(cell_state)
   Tanh(cell_state_scale_power, cell_state_shape, cell_state_data,
        cell_state_shape, buffer);
   // Update the hidden state
   Mul(cell_state_shape, mul_params, buffer, output_gate_output,
-      tflite::micro::GetTensorData<ActivationType>(hidden_state) +
+      tflite_micro::micro::GetTensorData<ActivationType>(hidden_state) +
           step_info.HiddenStateOffset());
 }
 
@@ -400,13 +400,13 @@ void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
   CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
       step_info, op_data.forget_gate_parameters,
       // Input FC
-      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmInputToForgetWeightsTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmForgetGateBiasTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputToForgetWeightsTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmForgetGateBiasTensor),
       // Recurrent FC
       kernel_content.HiddenStateTensor(),
       kernel_content.GetInternalTensor(
-          tflite::kLstmRecurrentToForgetWeightsTensor),
+          tflite_micro::kLstmRecurrentToForgetWeightsTensor),
       /*recurrent_bias*/ nullptr,
       // Output
       forget_gate_output,
@@ -418,13 +418,13 @@ void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
   CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
       step_info, op_data.input_gate_parameters,
       // Input FC
-      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmInputToInputWeightsTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmInputGateBiasTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputToInputWeightsTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputGateBiasTensor),
       // Recurrent FC
       kernel_content.HiddenStateTensor(),
       kernel_content.GetInternalTensor(
-          tflite::kLstmRecurrentToInputWeightsTensor),
+          tflite_micro::kLstmRecurrentToInputWeightsTensor),
       /*recurrent_bias*/ nullptr,
       // Output
       input_gate_output,
@@ -436,13 +436,13 @@ void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
   CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
       step_info, op_data.cell_gate_parameters,
       // Input FC
-      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmInputToCellWeightsTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmCellGateBiasTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputToCellWeightsTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmCellGateBiasTensor),
       // Recurrent FC
       kernel_content.HiddenStateTensor(),
       kernel_content.GetInternalTensor(
-          tflite::kLstmRecurrentToCellWeightsTensor),
+          tflite_micro::kLstmRecurrentToCellWeightsTensor),
       /*recurrent_bias*/ nullptr,
       // Output
       cell_gate_output,
@@ -465,13 +465,13 @@ void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
   CalculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
       step_info, op_data.output_gate_parameters,
       // Input FC
-      kernel_content.GetInternalTensor(tflite::kLstmInputTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmInputToOutputWeightsTensor),
-      kernel_content.GetInternalTensor(tflite::kLstmOutputGateBiasTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmInputToOutputWeightsTensor),
+      kernel_content.GetInternalTensor(tflite_micro::kLstmOutputGateBiasTensor),
       // Recurrent FC
       kernel_content.HiddenStateTensor(),
       kernel_content.GetInternalTensor(
-          tflite::kLstmRecurrentToOutputWeightsTensor),
+          tflite_micro::kLstmRecurrentToOutputWeightsTensor),
       /*recurrent_bias*/ nullptr,
       // Output
       output_gate_output,
@@ -479,7 +479,7 @@ void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
       gate_internal_buffer, kTfLiteActSigmoid);
 
   CellType* tanh_activated_cell_buffer = buffers.buffer0;  // reuse buffer
-  tflite::lstm_internal::UpdateLstmHidden<CellType, ActivationType>(
+  tflite_micro::lstm_internal::UpdateLstmHidden<CellType, ActivationType>(
       step_info, kernel_content.CellStateTensor(),
       kernel_content.HiddenStateTensor(), output_gate_output,
       inter_gate_params.output_mul_params,
@@ -490,13 +490,13 @@ void LstmStep(const LstmStepManager& step_info, const OpDataLSTM& op_data,
   // Check offset validity to avoid memory overflow
   TFLITE_DCHECK_LE(
       step_info.OutputOffset() + step_info.StateShape().FlatSize(),
-      tflite::micro::GetTensorShape(kernel_content.output_tensor).FlatSize());
+      tflite_micro::micro::GetTensorShape(kernel_content.output_tensor).FlatSize());
   // record the output (from the updated hidden state)
-  ActivationType* output_ptr = tflite::micro::GetTensorData<ActivationType>(
+  ActivationType* output_ptr = tflite_micro::micro::GetTensorData<ActivationType>(
       kernel_content.output_tensor);
   const auto* hidden_state = kernel_content.HiddenStateTensor();
   std::memcpy(output_ptr + step_info.OutputOffset(),
-              tflite::micro::GetTensorData<ActivationType>(hidden_state) +
+              tflite_micro::micro::GetTensorData<ActivationType>(hidden_state) +
                   step_info.HiddenStateOffset(),
               step_info.StateShape().FlatSize() * sizeof(ActivationType));
 }
@@ -536,6 +536,6 @@ TfLiteStatus EvalLstm(const OpDataLSTM& op_data,
   }
   return kTfLiteOk;
 }
-}  // namespace tflite
+}  // namespace tflite_micro
 
 #endif  // TENSORFLOW_LITE_MICRO_KERNELS_LSTM_EVAL_16ACT_H_