From 05c1c5a1beb8c1c17e2a06000727f9f094bc6e37 Mon Sep 17 00:00:00 2001 From: Nina Drozd Date: Tue, 22 Aug 2023 12:41:55 +0100 Subject: MLECO-4072: update MLEK dependencies to 23.08 * version updates in cmakelists file * update submodules to 23.08 versions * updates to documentation - vela 3.9.0 Change-Id: I5e24d5729ecbd2289b04fcc845fb44f455ab38d5 Signed-off-by: Nina Drozd --- .../api/common/include/TensorFlowLiteMicro.hpp | 3 - source/application/api/common/source/Model.cc | 2 +- .../include/MicroMutableAllOpsResolver.hpp | 134 +++++++++++++++++++++ .../inference_runner/include/TestModel.hpp | 7 +- .../api/use_case/inference_runner/src/TestModel.cc | 4 +- 5 files changed, 141 insertions(+), 9 deletions(-) create mode 100644 source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp (limited to 'source') diff --git a/source/application/api/common/include/TensorFlowLiteMicro.hpp b/source/application/api/common/include/TensorFlowLiteMicro.hpp index 17dfd64..6957b1b 100644 --- a/source/application/api/common/include/TensorFlowLiteMicro.hpp +++ b/source/application/api/common/include/TensorFlowLiteMicro.hpp @@ -30,19 +30,16 @@ #pragma clang diagnostic ignored "-Wunused-parameter" #include "tensorflow/lite/micro/micro_mutable_op_resolver.h" #include "tensorflow/lite/micro/micro_interpreter.h" - #include "tensorflow/lite/micro/all_ops_resolver.h" #pragma clang diagnostic pop #elif defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include "tensorflow/lite/micro/micro_mutable_op_resolver.h" #include "tensorflow/lite/micro/micro_interpreter.h" - #include "tensorflow/lite/micro/all_ops_resolver.h" #pragma GCC diagnostic pop #else #include "tensorflow/lite/micro/micro_mutable_op_resolver.h" #include "tensorflow/lite/micro/micro_interpreter.h" - #include "tensorflow/lite/micro/all_ops_resolver.h" #endif #include "tensorflow/lite/c/common.h" diff --git a/source/application/api/common/source/Model.cc b/source/application/api/common/source/Model.cc index da8f46b..b344a53 100644 --- a/source/application/api/common/source/Model.cc +++ b/source/application/api/common/source/Model.cc @@ -193,7 +193,7 @@ void arm::app::Model::LogInterpreterInfo() for (size_t i = 0; i < nOperators; ++i) { const tflite::Operator* op = subgraph->operators()->Get(i); const tflite::OperatorCode* opcode = opcodes->Get(op->opcode_index()); - const TfLiteRegistration_V1* reg = nullptr; + const TFLMRegistration* reg = nullptr; tflite::GetRegistrationFromOpCode(opcode, this->GetOpResolver(), ®); std::string opName; diff --git a/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp b/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp new file mode 100644 index 0000000..df55a83 --- /dev/null +++ b/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp @@ -0,0 +1,134 @@ +/* + * SPDX-FileCopyrightText: Copyright 2023 Arm Limited and/or its affiliates + * SPDX-License-Identifier: Apache-2.0 + * + * 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 INF_RUNNER_MICRO_MUTABLE_ALLOPS_RESOLVER_HPP +#define INF_RUNNER_MICRO_MUTABLE_ALLOPS_RESOLVER_HPP + +#include + +constexpr int kNumberOperators = 97; + +namespace arm { +namespace app { + + inline tflite::MicroMutableOpResolver get_resolver() { + tflite::MicroMutableOpResolver micro_op_resolver; + + micro_op_resolver.AddAbs(); + micro_op_resolver.AddAdd(); + micro_op_resolver.AddAddN(); + micro_op_resolver.AddArgMax(); + micro_op_resolver.AddArgMin(); + micro_op_resolver.AddAssignVariable(); + micro_op_resolver.AddAveragePool2D(); + micro_op_resolver.AddBatchToSpaceNd(); + micro_op_resolver.AddBroadcastArgs(); + micro_op_resolver.AddBroadcastTo(); + micro_op_resolver.AddCallOnce(); + micro_op_resolver.AddCast(); + micro_op_resolver.AddCeil(); + micro_op_resolver.AddCircularBuffer(); + micro_op_resolver.AddConcatenation(); + micro_op_resolver.AddConv2D(); + micro_op_resolver.AddCos(); + micro_op_resolver.AddCumSum(); + micro_op_resolver.AddDepthToSpace(); + micro_op_resolver.AddDepthwiseConv2D(); + micro_op_resolver.AddDequantize(); + micro_op_resolver.AddDetectionPostprocess(); + micro_op_resolver.AddDiv(); + micro_op_resolver.AddElu(); + micro_op_resolver.AddEqual(); + micro_op_resolver.AddEthosU(); + micro_op_resolver.AddExp(); + micro_op_resolver.AddExpandDims(); + micro_op_resolver.AddFill(); + micro_op_resolver.AddFloor(); + micro_op_resolver.AddFloorDiv(); + micro_op_resolver.AddFloorMod(); + micro_op_resolver.AddFullyConnected(); + micro_op_resolver.AddGather(); + micro_op_resolver.AddGatherNd(); + micro_op_resolver.AddGreater(); + micro_op_resolver.AddGreaterEqual(); + micro_op_resolver.AddHardSwish(); + micro_op_resolver.AddIf(); + micro_op_resolver.AddL2Normalization(); + micro_op_resolver.AddL2Pool2D(); + micro_op_resolver.AddLeakyRelu(); + micro_op_resolver.AddLess(); + micro_op_resolver.AddLessEqual(); + micro_op_resolver.AddLog(); + micro_op_resolver.AddLogicalAnd(); + micro_op_resolver.AddLogicalNot(); + micro_op_resolver.AddLogicalOr(); + micro_op_resolver.AddLogistic(); + micro_op_resolver.AddLogSoftmax(); + micro_op_resolver.AddMaxPool2D(); + micro_op_resolver.AddMaximum(); + micro_op_resolver.AddMean(); + micro_op_resolver.AddMinimum(); + micro_op_resolver.AddMirrorPad(); + micro_op_resolver.AddMul(); + micro_op_resolver.AddNeg(); + micro_op_resolver.AddNotEqual(); + micro_op_resolver.AddPack(); + micro_op_resolver.AddPad(); + micro_op_resolver.AddPadV2(); + micro_op_resolver.AddPrelu(); + micro_op_resolver.AddQuantize(); + micro_op_resolver.AddReadVariable(); + micro_op_resolver.AddReduceMax(); + micro_op_resolver.AddRelu(); + micro_op_resolver.AddRelu6(); + micro_op_resolver.AddReshape(); + micro_op_resolver.AddResizeBilinear(); + micro_op_resolver.AddResizeNearestNeighbor(); + micro_op_resolver.AddRound(); + micro_op_resolver.AddRsqrt(); + micro_op_resolver.AddSelectV2(); + micro_op_resolver.AddShape(); + micro_op_resolver.AddSin(); + micro_op_resolver.AddSlice(); + micro_op_resolver.AddSoftmax(); + micro_op_resolver.AddSpaceToBatchNd(); + micro_op_resolver.AddSpaceToDepth(); + micro_op_resolver.AddSplit(); + micro_op_resolver.AddSplitV(); + micro_op_resolver.AddSqrt(); + micro_op_resolver.AddSquare(); + micro_op_resolver.AddSquaredDifference(); + micro_op_resolver.AddSqueeze(); + micro_op_resolver.AddStridedSlice(); + micro_op_resolver.AddSub(); + micro_op_resolver.AddSum(); + micro_op_resolver.AddSvdf(); + micro_op_resolver.AddTanh(); + micro_op_resolver.AddTranspose(); + micro_op_resolver.AddTransposeConv(); + micro_op_resolver.AddUnidirectionalSequenceLSTM(); + micro_op_resolver.AddUnpack(); + micro_op_resolver.AddVarHandle(); + micro_op_resolver.AddWhile(); + micro_op_resolver.AddZerosLike(); + + return micro_op_resolver; + } + +} /* namespace app */ +} /* namespace arm */ + +#endif /* INF_RUNNER_MICRO_MUTABLE_ALLOPS_RESOLVER_HPP */ diff --git a/source/application/api/use_case/inference_runner/include/TestModel.hpp b/source/application/api/use_case/inference_runner/include/TestModel.hpp index 80318e6..bc6a0fb 100644 --- a/source/application/api/use_case/inference_runner/include/TestModel.hpp +++ b/source/application/api/use_case/inference_runner/include/TestModel.hpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates + * SPDX-FileCopyrightText: Copyright 2021, 2023 Arm Limited and/or its affiliates * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,6 +18,7 @@ #define INF_RUNNER_TESTMODEL_HPP #include "Model.hpp" +#include "MicroMutableAllOpsResolver.hpp" namespace arm { namespace app { @@ -26,7 +27,7 @@ namespace app { protected: /** @brief Gets the reference to op resolver interface class. */ - const tflite::AllOpsResolver& GetOpResolver() override; + const tflite::MicroMutableOpResolver& GetOpResolver() override; /** @brief Adds operations to the op resolver instance, not needed as using AllOpsResolver. */ bool EnlistOperations() override {return false;} @@ -34,7 +35,7 @@ namespace app { private: /* No need to define individual ops at the cost of extra memory. */ - tflite::AllOpsResolver m_opResolver; + tflite::MicroMutableOpResolver m_opResolver; }; } /* namespace app */ diff --git a/source/application/api/use_case/inference_runner/src/TestModel.cc b/source/application/api/use_case/inference_runner/src/TestModel.cc index 660c3e6..c69a98d 100644 --- a/source/application/api/use_case/inference_runner/src/TestModel.cc +++ b/source/application/api/use_case/inference_runner/src/TestModel.cc @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright 2021 Arm Limited and/or its affiliates + * SPDX-FileCopyrightText: Copyright 2021, 2023 Arm Limited and/or its affiliates * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,7 +17,7 @@ #include "TestModel.hpp" #include "log_macros.h" -const tflite::AllOpsResolver& arm::app::TestModel::GetOpResolver() +const tflite::MicroMutableOpResolver& arm::app::TestModel::GetOpResolver() { return this->m_opResolver; } -- cgit v1.2.1