From 21fe06fad6760a0d453f2de9c8dd790983ae940c Mon Sep 17 00:00:00 2001 From: Mike Kelly Date: Mon, 16 May 2022 23:10:42 +0100 Subject: IVGCVSW-6929 Support for models with implicit expanded dimensions * Added allow-expanded-dims to TFLite parser and ArmNN delegate * If true ArmNN will disregard dimensions with a size of 1 when validating tensor shapes. Tensor sizes must still match. * This allows us to support models where tensors have expanded dimensions (i.e. extra dimensions with a size of 1). * Fixed bug in Network where it assumed that only the first option could be ShapeInferenceMethod. * Fixed bug where m_ShapeInferenceMethod was lost when copying or moving Graphs. * Changed Delegate to pass "infer-output-shape", "allow-expanded-dims" and other BackendOptions through to the Network during construction. Signed-off-by: Mike Kelly Change-Id: Ibe7c5ae6597796fc9164cb07bd372bd7f8f8cacf --- delegate/include/DelegateOptions.hpp | 11 ++++ delegate/src/DelegateOptions.cpp | 18 ++++++ delegate/src/armnn_delegate.cpp | 2 +- include/armnn/backends/OptimizationViews.hpp | 2 +- include/armnn/backends/WorkloadData.hpp | 12 ++++ include/armnnTfLiteParser/ITfLiteParser.hpp | 4 +- include/armnnUtils/TensorUtils.hpp | 2 + src/armnn/Graph.cpp | 2 + src/armnn/Graph.hpp | 10 ++- src/armnn/Layer.cpp | 41 ++++++++++-- src/armnn/Layer.hpp | 8 +++ src/armnn/Network.cpp | 29 +++++++-- src/armnn/Network.hpp | 1 + src/armnn/layers/LayerCloneBase.hpp | 1 + src/armnn/layers/LayerWithParameters.hpp | 1 + src/armnnTfLiteParser/TfLiteParser.cpp | 25 +++++--- src/armnnUtils/TensorUtils.cpp | 16 +++++ src/backends/backendsCommon/WorkloadData.cpp | 73 +++++++++++++++------- src/backends/cl/ClBackend.cpp | 2 +- src/backends/neon/NeonBackend.cpp | 5 +- src/backends/neon/NeonBackend.hpp | 3 +- tests/ExecuteNetwork/ExecuteNetwork.cpp | 1 + tests/ExecuteNetwork/ExecuteNetworkParams.cpp | 21 +++++++ tests/ExecuteNetwork/ExecuteNetworkParams.hpp | 1 + .../ExecuteNetworkProgramOptions.cpp | 7 +++ tests/InferenceModel.hpp | 3 + 26 files changed, 252 insertions(+), 49 deletions(-) diff --git a/delegate/include/DelegateOptions.hpp b/delegate/include/DelegateOptions.hpp index 7f7eaa5bb9..d789ea7285 100644 --- a/delegate/include/DelegateOptions.hpp +++ b/delegate/include/DelegateOptions.hpp @@ -163,6 +163,17 @@ public: * Possible values: [filenameString] \n * Description: Serialize the optimized network to the file specified in "dot" format. * + * Option key: "infer-output-shape" \n + * Possible values: ["true"/"false"] \n + * Description: Infers output tensor shape from input tensor shape and validate where applicable. + * + * Option key: "allow-expanded-dims" \n + * Possible values: ["true"/"false"] \n + * Description: If true will disregard dimensions with a size of 1 when validating tensor shapes but tensor + * sizes must still match. \n + * This is an Experimental parameter that is incompatible with "infer-output-shape". \n + * This parameter may be removed in a later update. + * * @param[in] option_keys Delegate option names * @param[in] options_values Delegate option values * @param[in] num_options Number of delegate options diff --git a/delegate/src/DelegateOptions.cpp b/delegate/src/DelegateOptions.cpp index 9413a4689a..f3e13c90c6 100644 --- a/delegate/src/DelegateOptions.cpp +++ b/delegate/src/DelegateOptions.cpp @@ -155,6 +155,24 @@ DelegateOptions::DelegateOptions(char const* const* options_keys, else if (std::string(options_keys[i]) == std::string("debug-data")) { optimizerOptions.m_Debug = armnn::stringUtils::StringToBool(options_values[i]); + } + // Infer output-shape + else if (std::string(options_keys[i]) == std::string("infer-output-shape")) + { + armnn::BackendOptions backendOption("ShapeInferenceMethod", + { + { "InferAndValidate", armnn::stringUtils::StringToBool(options_values[i]) } + }); + optimizerOptions.m_ModelOptions.push_back(backendOption); + } + // Allow expanded dims + else if (std::string(options_keys[i]) == std::string("allow-expanded-dims")) + { + armnn::BackendOptions backendOption("AllowExpandedDims", + { + { "AllowExpandedDims", armnn::stringUtils::StringToBool(options_values[i]) } + }); + optimizerOptions.m_ModelOptions.push_back(backendOption); } // Process memory-import else if (std::string(options_keys[i]) == std::string("memory-import")) diff --git a/delegate/src/armnn_delegate.cpp b/delegate/src/armnn_delegate.cpp index 4d71f26b09..6e1a91f9e4 100644 --- a/delegate/src/armnn_delegate.cpp +++ b/delegate/src/armnn_delegate.cpp @@ -308,7 +308,7 @@ ArmnnSubgraph* ArmnnSubgraph::Create(TfLiteContext* tfLiteContext, DelegateData delegateData(delegate->m_Options.GetBackends()); // Build ArmNN Network - armnn::NetworkOptions networkOptions = {}; + armnn::NetworkOptions networkOptions = delegate->m_Options.GetOptimizerOptions().m_ModelOptions; armnn::NetworkId networkId; delegateData.m_Network = armnn::INetwork::Create(networkOptions); diff --git a/include/armnn/backends/OptimizationViews.hpp b/include/armnn/backends/OptimizationViews.hpp index f7346de7ab..29ee68c67e 100644 --- a/include/armnn/backends/OptimizationViews.hpp +++ b/include/armnn/backends/OptimizationViews.hpp @@ -13,7 +13,7 @@ namespace armnn class OptimizationViews { public: - OptimizationViews() = default; + OptimizationViews(NetworkOptions networkOptions = {}) : m_INetwork(INetwork::Create(networkOptions)) {} OptimizationViews(const OptimizationViews&) = delete; OptimizationViews& operator=(const OptimizationViews&) = delete; OptimizationViews(OptimizationViews&&) = default; diff --git a/include/armnn/backends/WorkloadData.hpp b/include/armnn/backends/WorkloadData.hpp index ed89f9638c..1a2f34e21f 100644 --- a/include/armnn/backends/WorkloadData.hpp +++ b/include/armnn/backends/WorkloadData.hpp @@ -29,6 +29,16 @@ struct QueueDescriptor virtual ~QueueDescriptor() = default; + void ValidateTensorNumDimensions(const TensorInfo& tensor, + std::string const& descName, + unsigned int numDimensions, + std::string const& tensorName) const; + + void ValidateTensorNumDimNumElem(const TensorInfo& tensorInfo, + unsigned int numDimension, + unsigned int numElements, + std::string const& tensorName) const; + void ValidateInputsOutputs(const std::string& descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const; @@ -39,6 +49,8 @@ struct QueueDescriptor return static_cast(m_AdditionalInfoObject); } + bool m_AllowExpandedDims = false; + protected: QueueDescriptor() : m_AdditionalInfoObject(nullptr) diff --git a/include/armnnTfLiteParser/ITfLiteParser.hpp b/include/armnnTfLiteParser/ITfLiteParser.hpp index b286c1ee4c..ea6e87a0a7 100644 --- a/include/armnnTfLiteParser/ITfLiteParser.hpp +++ b/include/armnnTfLiteParser/ITfLiteParser.hpp @@ -29,9 +29,11 @@ public: struct TfLiteParserOptions { TfLiteParserOptions() - : m_StandInLayerForUnsupported(false), + : m_AllowExpandedDims(false), + m_StandInLayerForUnsupported(false), m_InferAndValidate(false) {} + bool m_AllowExpandedDims; bool m_StandInLayerForUnsupported; bool m_InferAndValidate; }; diff --git a/include/armnnUtils/TensorUtils.hpp b/include/armnnUtils/TensorUtils.hpp index 6a975255c6..fc2f51061c 100644 --- a/include/armnnUtils/TensorUtils.hpp +++ b/include/armnnUtils/TensorUtils.hpp @@ -34,6 +34,8 @@ std::pair FindMinMax(armnn::ITensorHandle* tensorHandle); armnn::TensorShape ExpandDims(const armnn::TensorShape& tensorShape, int axis); +std::vector SqueezeDims(const armnn::TensorShape& tensorShape); + unsigned int GetNumElementsBetween(const armnn::TensorShape& shape, unsigned int firstAxisInclusive, unsigned int lastAxisExclusive); diff --git a/src/armnn/Graph.cpp b/src/armnn/Graph.cpp index 8500e529b0..ae773cc876 100644 --- a/src/armnn/Graph.cpp +++ b/src/armnn/Graph.cpp @@ -26,6 +26,8 @@ namespace armnn Graph::Graph(const Graph& other) : m_LayersInOrder(other.m_LayersInOrder) +, m_AllowExpandedDims(other.m_AllowExpandedDims) +, m_ShapeInferenceMethod(other.m_ShapeInferenceMethod) , m_Profiler(other.m_Profiler) { std::unordered_map otherToClonedMap; diff --git a/src/armnn/Graph.hpp b/src/armnn/Graph.hpp index 0c34d35685..5edf34c179 100644 --- a/src/armnn/Graph.hpp +++ b/src/armnn/Graph.hpp @@ -95,8 +95,9 @@ public: const Graph& m_Graph; }; - Graph(bool shapeInferenceMethod = false) + Graph(bool shapeInferenceMethod = false, bool allowExpandedDims = false) : m_LayersInOrder(true) + , m_AllowExpandedDims(allowExpandedDims) , m_ShapeInferenceMethod(shapeInferenceMethod ? ShapeInferenceMethod::InferAndValidate : ShapeInferenceMethod::ValidateOnly) , m_Profiler(std::make_shared()) @@ -118,11 +119,12 @@ public: m_LayersInOrder = std::move(other.m_LayersInOrder); m_Views = std::move(other.m_Views); m_Profiler = std::move(other.m_Profiler); - other.ForEachLayer([this](Layer* otherLayer) { otherLayer->Reparent(*this, m_Layers.end()); }); + m_AllowExpandedDims = other.m_AllowExpandedDims; + m_ShapeInferenceMethod = other.m_ShapeInferenceMethod; ARMNN_ASSERT(other.m_PosInGraphMap.empty()); ARMNN_ASSERT(other.m_Layers.empty()); @@ -272,8 +274,11 @@ private: mutable LayerList m_Layers; mutable bool m_LayersInOrder; + bool m_AllowExpandedDims; + std::map> m_Views; ShapeInferenceMethod m_ShapeInferenceMethod; + std::shared_ptr m_Profiler; // Throws exception due to a layer input not being connected to an output slot. @@ -424,6 +429,7 @@ inline LayerT* Graph::AddLayer(Args&&... args) LayerT* const layer = new LayerInGraph(*this, std::forward(args)...); layer->SetShapeInferenceMethod(m_ShapeInferenceMethod); + layer->SetAllowExpandedDims(m_AllowExpandedDims); NotifyObservables(GraphEvent::LayerAdded, layer); diff --git a/src/armnn/Layer.cpp b/src/armnn/Layer.cpp index 3241b5024e..b1d495244d 100644 --- a/src/armnn/Layer.cpp +++ b/src/armnn/Layer.cpp @@ -11,6 +11,8 @@ #include +#include + #include #include @@ -425,11 +427,40 @@ void Layer::ValidateAndCopyShape(const TensorShape& outputShape, { if (shapeInferenceMethod == ShapeInferenceMethod::ValidateOnly) { - ConditionalThrowIfNotEqual( - layerName + ": TensorShape set on OutputSlot[0] does not match the inferred shape.", - outputShape, - inferredShape); - return; + if (m_AllowExpandedDims) + { + std::vector outputDims = armnnUtils::SqueezeDims(outputShape); + std::vector inferredDims = armnnUtils::SqueezeDims(inferredShape); + + if (outputDims.size() != inferredDims.size()) + { + std::stringstream ss; + ss << layerName << ": TensorShape set on OutputSlot[" << outputSlotIndex << + "] does not match the inferred shape. "; + ss << outputShape << " != " << inferredShape; + throw LayerValidationException(ss.str()); + } + for (unsigned int i = 0; i < outputDims.size(); ++i) + { + if (outputDims[i] != inferredDims[i]) + { + std::stringstream ss; + ss << layerName << ": TensorShape set on OutputSlot[" << outputSlotIndex << + "] does not match the inferred shape at dimension index ["; + ss << i << "] " << outputShape << " != " << inferredShape; + throw LayerValidationException(ss.str()); + } + } + return; + } + else + { + ConditionalThrowIfNotEqual( + layerName + ": TensorShape set on OutputSlot[0] does not match the inferred shape.", + outputShape, + inferredShape); + return; + } } if (outputShape.GetDimensionality() == Dimensionality::Specified) diff --git a/src/armnn/Layer.hpp b/src/armnn/Layer.hpp index 114d69c652..767cf97eb3 100644 --- a/src/armnn/Layer.hpp +++ b/src/armnn/Layer.hpp @@ -238,6 +238,7 @@ public: } ShapeInferenceMethod GetShapeInferenceMethod() const { return m_ShapeInferenceMethod; }; + bool GetAllowExpandedDims() const { return m_AllowExpandedDims; }; const std::vector& GetInputSlots() const { return m_InputSlots; } const std::vector& GetOutputSlots() const { return m_OutputSlots; } @@ -343,6 +344,11 @@ public: m_ShapeInferenceMethod = shapeInferenceMethod; } + void SetAllowExpandedDims(bool allowExpandedDims) + { + m_AllowExpandedDims = allowExpandedDims; + } + template std::shared_ptr GetAdditionalInformation() const { @@ -428,6 +434,8 @@ private: mutable LayerPriority m_Priority = 0; mutable bool m_Visiting = false; + bool m_AllowExpandedDims = false; + LayerGuid m_Guid; std::list m_RelatedLayerNames; diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp index 77ad5c4dc2..6a646d3cc8 100644 --- a/src/armnn/Network.cpp +++ b/src/armnn/Network.cpp @@ -1854,16 +1854,35 @@ IOptimizedNetworkPtr Optimize(const INetwork& inNetwork, bool NetworkImpl::GetShapeInferenceMethod() { - if (m_NetworkOptions.size() > 0 && m_NetworkOptions[0].GetBackendId().Get() == "ShapeInferenceMethod") + bool shapeInferenceMethod = false; + + ParseOptions(m_NetworkOptions, "ShapeInferenceMethod", [&](std::string name, const BackendOptions::Var& value) { - return m_NetworkOptions[0].GetOption(0).GetValue().AsBool(); - } + if (name == "InferAndValidate") + { + shapeInferenceMethod |= value.AsBool(); + } + }); + return shapeInferenceMethod; +} - return false; +bool NetworkImpl::GetAllowExpandedDims() +{ + bool allowExpandedDims = false; + + ParseOptions(m_NetworkOptions, "AllowExpandedDims", [&](std::string name, const BackendOptions::Var& value) + { + if (name == "AllowExpandedDims") + { + allowExpandedDims |= value.AsBool(); + } + }); + return allowExpandedDims; } + NetworkImpl::NetworkImpl(NetworkOptions networkOptions) : m_NetworkOptions(networkOptions), - m_Graph(std::make_unique(GetShapeInferenceMethod())) + m_Graph(std::make_unique(GetShapeInferenceMethod(), GetAllowExpandedDims())) {} NetworkImpl::~NetworkImpl() diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp index c2be600d05..6c7c2f5c7e 100644 --- a/src/armnn/Network.hpp +++ b/src/armnn/Network.hpp @@ -262,6 +262,7 @@ public: private: bool GetShapeInferenceMethod(); + bool GetAllowExpandedDims(); NetworkOptions m_NetworkOptions; std::unique_ptr m_Graph; diff --git a/src/armnn/layers/LayerCloneBase.hpp b/src/armnn/layers/LayerCloneBase.hpp index 348b1f3bf6..54b64c5852 100644 --- a/src/armnn/layers/LayerCloneBase.hpp +++ b/src/armnn/layers/LayerCloneBase.hpp @@ -19,6 +19,7 @@ LayerType* Layer::CloneBase(Graph& graph, Params&& ... params) const layer->SetBackendId(GetBackendId()); layer->SetGuid(GetGuid()); layer->SetShapeInferenceMethod(m_ShapeInferenceMethod); + layer->SetAllowExpandedDims(m_AllowExpandedDims); return layer; } diff --git a/src/armnn/layers/LayerWithParameters.hpp b/src/armnn/layers/LayerWithParameters.hpp index 2ac16c5f5f..8d9ddffc24 100644 --- a/src/armnn/layers/LayerWithParameters.hpp +++ b/src/armnn/layers/LayerWithParameters.hpp @@ -43,6 +43,7 @@ protected: WorkloadInfo PrepInfoAndDesc(QueueDescriptor& descriptor) const { descriptor.m_Parameters = m_Param; + descriptor.m_AllowExpandedDims = GetAllowExpandedDims(); return Layer::PrepInfoAndDesc(descriptor); } diff --git a/src/armnnTfLiteParser/TfLiteParser.cpp b/src/armnnTfLiteParser/TfLiteParser.cpp index aa07f7b3f9..49f1f9f856 100644 --- a/src/armnnTfLiteParser/TfLiteParser.cpp +++ b/src/armnnTfLiteParser/TfLiteParser.cpp @@ -793,16 +793,27 @@ INetworkPtr TfLiteParserImpl::CreateNetworkFromModel() using NetworkOptions = std::vector; NetworkOptions networkOptions = {}; - if (m_Options && m_Options.value().m_InferAndValidate) + if (m_Options) { - BackendOptions shapeInferenceMethodOption("ShapeInferenceMethod", - { - { "InferAndValidate", true } - }); + if (m_Options.value().m_InferAndValidate) + { + BackendOptions shapeInferenceMethodOption("ShapeInferenceMethod", + { + { "InferAndValidate", true } + }); - networkOptions.push_back(shapeInferenceMethodOption); - } + networkOptions.push_back(shapeInferenceMethodOption); + } + if (m_Options.value().m_AllowExpandedDims) + { + BackendOptions shapeInferenceMethodOption("AllowExpandedDims", + { + { "AllowExpandedDims", true } + }); + networkOptions.push_back(shapeInferenceMethodOption); + } + } m_Network = INetwork::Create(networkOptions); ARMNN_ASSERT(m_Model.get() != nullptr); diff --git a/src/armnnUtils/TensorUtils.cpp b/src/armnnUtils/TensorUtils.cpp index 5b5b2bd6e6..d77f5d74c3 100644 --- a/src/armnnUtils/TensorUtils.cpp +++ b/src/armnnUtils/TensorUtils.cpp @@ -131,6 +131,22 @@ TensorShape ExpandDims(const TensorShape& tensorShape, int axis) return TensorShape(outputDim, outputShape.data()); } +std::vector SqueezeDims(const TensorShape& tensorShape) +{ + unsigned int outputDimSize = 0; + std::vector squeezedDims; + + for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i) + { + if (tensorShape[i] != 1) + { + squeezedDims.push_back(tensorShape[i]); + ++outputDimSize; + } + } + return squeezedDims; +} + unsigned int GetNumElementsBetween(const TensorShape& shape, const unsigned int firstAxisInclusive, const unsigned int lastAxisExclusive) diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp index 37fda3e210..2194b487d3 100644 --- a/src/backends/backendsCommon/WorkloadData.cpp +++ b/src/backends/backendsCommon/WorkloadData.cpp @@ -107,18 +107,6 @@ void ValidateNumOutputs(const WorkloadInfo& workloadInfo, std::string const& des } //--------------------------------------------------------------- -void ValidateTensorNumDimensions(const TensorInfo& tensor, - std::string const& descName, - unsigned int numDimensions, - std::string const& tensorName) -{ - if (tensor.GetNumDimensions() != numDimensions) - { - throw InvalidArgumentException(descName + ": Expected " + to_string(numDimensions) + " but got " + - to_string(tensor.GetNumDimensions()) + " dimensions for " + - tensorName + " tensor."); - } -} //--------------------------------------------------------------- void ValidateTensorNumElements(const TensorInfo& tensor, @@ -134,17 +122,6 @@ void ValidateTensorNumElements(const TensorInfo& tensor, } } -//--------------------------------------------------------------- -void ValidateTensorNumDimNumElem(const TensorInfo& tensorInfo, - unsigned int numDimension, - unsigned int numElements, - std::string const& tensorName) -{ - const std::string functionName{"ValidateTensorNumDimNumElem"}; - ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName); - ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName); -} - //--------------------------------------------------------------- void ValidateTensorDataType(const TensorInfo& tensor, DataType dataType, const std::string& descName, std::string const& tensorName) @@ -444,6 +421,56 @@ void ValidatePerAxisQuantization(const TensorInfo& inputInfo, } // anonymous namespace +//--------------------------------------------------------------- +void QueueDescriptor::ValidateTensorNumDimensions(const TensorInfo& tensor, + std::string const& descName, + unsigned int numDimensions, + std::string const& tensorName) const +{ + // If we're allowing expanded dimensions then numDimensions becomes the minimum number of Dimensions we can allow. + // Throw an Exception if the tensors has fewer than numDimensions or if the squeezed dimensions are greater than + // numDimensions. + if (m_AllowExpandedDims) + { + unsigned int squeezedDims = 0; + + for (unsigned int i = 0; i < tensor.GetNumDimensions(); ++i) + { + if (tensor.GetShape()[i] != 1) + { + ++squeezedDims; + } + } + if (tensor.GetNumDimensions() < numDimensions || squeezedDims > numDimensions) + { + throw InvalidArgumentException(descName + ": Expected " + to_string(numDimensions) + " or less but got " + + to_string(tensor.GetNumDimensions()) + " dimensions for " + + tensorName + " tensor."); + } + } + else + { + if (tensor.GetNumDimensions() != numDimensions) + { + throw InvalidArgumentException(descName + ": Expected " + to_string(numDimensions) + " but got " + + to_string(tensor.GetNumDimensions()) + " dimensions for " + + tensorName + " tensor."); + } + } +} + +//--------------------------------------------------------------- +void QueueDescriptor::ValidateTensorNumDimNumElem(const TensorInfo& tensorInfo, + unsigned int numDimension, + unsigned int numElements, + std::string const& tensorName) const +{ + const std::string functionName{"ValidateTensorNumDimNumElem"}; + ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName); + ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName); +} + +//--------------------------------------------------------------- void QueueDescriptor::ValidateInputsOutputs(const std::string& descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const { diff --git a/src/backends/cl/ClBackend.cpp b/src/backends/cl/ClBackend.cpp index bd1b94e79f..1fe53de62a 100644 --- a/src/backends/cl/ClBackend.cpp +++ b/src/backends/cl/ClBackend.cpp @@ -276,7 +276,7 @@ std::unique_ptr ClBackend::GetDefaultAllocator() const OptimizationViews ClBackend::OptimizeSubgraphView(const SubgraphView& subgraph, const ModelOptions& modelOptions) const { - OptimizationViews optimizationViews; + OptimizationViews optimizationViews(modelOptions); auto it = subgraph.endIConnectable(); bool isFastMathEnabled = false; diff --git a/src/backends/neon/NeonBackend.cpp b/src/backends/neon/NeonBackend.cpp index 24336426ea..968bce48c8 100644 --- a/src/backends/neon/NeonBackend.cpp +++ b/src/backends/neon/NeonBackend.cpp @@ -139,9 +139,10 @@ IBackendInternal::ILayerSupportSharedPtr NeonBackend::GetLayerSupport(const Mode return layerSupport; } -OptimizationViews NeonBackend::OptimizeSubgraphView(const SubgraphView& subgraph) const +OptimizationViews NeonBackend::OptimizeSubgraphView(const SubgraphView& subgraph, + const ModelOptions& modelOptions) const { - OptimizationViews optimizationViews; + OptimizationViews optimizationViews(modelOptions); auto it = subgraph.endIConnectable(); std::map untouched; diff --git a/src/backends/neon/NeonBackend.hpp b/src/backends/neon/NeonBackend.hpp index e3e3782a7f..d407368d19 100644 --- a/src/backends/neon/NeonBackend.hpp +++ b/src/backends/neon/NeonBackend.hpp @@ -52,7 +52,8 @@ public: IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override; IBackendInternal::ILayerSupportSharedPtr GetLayerSupport(const ModelOptions& modelOptions) const override; - OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph) const override; + OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph, + const ModelOptions& modelOptions) const override; std::vector GetHandleFactoryPreferences() const override; diff --git a/tests/ExecuteNetwork/ExecuteNetwork.cpp b/tests/ExecuteNetwork/ExecuteNetwork.cpp index ddabf3c11f..f0a3d0821e 100644 --- a/tests/ExecuteNetwork/ExecuteNetwork.cpp +++ b/tests/ExecuteNetwork/ExecuteNetwork.cpp @@ -389,6 +389,7 @@ int MainImpl(const ExecuteNetworkParams& params, // Creates an InferenceModel, which will parse the model and load it into an IRuntime. typename InferenceModel::Params inferenceModelParams; inferenceModelParams.m_ModelPath = params.m_ModelPath; + inferenceModelParams.m_AllowExpandedDims = params.m_AllowExpandedDims; inferenceModelParams.m_IsModelBinary = params.m_IsModelBinary; inferenceModelParams.m_ComputeDevices = params.m_ComputeDevices; inferenceModelParams.m_DynamicBackendsPath = params.m_DynamicBackendsPath; diff --git a/tests/ExecuteNetwork/ExecuteNetworkParams.cpp b/tests/ExecuteNetwork/ExecuteNetworkParams.cpp index b3d18cdfd1..cc75bb4323 100644 --- a/tests/ExecuteNetwork/ExecuteNetworkParams.cpp +++ b/tests/ExecuteNetwork/ExecuteNetworkParams.cpp @@ -232,6 +232,11 @@ void ExecuteNetworkParams::ValidateParams() { ARMNN_LOG(warning) << "No input files provided, input tensors will be filled with 0s."; } + + if (m_AllowExpandedDims && m_InferOutputShape) + { + throw armnn::InvalidArgumentException("infer-output-shape and allow-expanded-dims cannot be used together."); + } } #if defined(ARMNN_TFLITE_DELEGATE) @@ -277,6 +282,22 @@ armnnDelegate::DelegateOptions ExecuteNetworkParams::ToDelegateOptions() const options.m_ModelOptions.push_back(gpuAcc); options.m_ModelOptions.push_back(cpuAcc); + if (m_InferOutputShape) + { + armnn::BackendOptions networkOption("ShapeInferenceMethod", + { + {"InferAndValidate", true} + }); + options.m_ModelOptions.push_back(networkOption); + } + if (m_AllowExpandedDims) + { + armnn::BackendOptions networkOption("AllowExpandedDims", + { + {"AllowExpandedDims", true} + }); + options.m_ModelOptions.push_back(networkOption); + } delegateOptions.SetOptimizerOptions(options); // If v,visualize-optimized-model is enabled then construct a file name for the dot file. diff --git a/tests/ExecuteNetwork/ExecuteNetworkParams.hpp b/tests/ExecuteNetwork/ExecuteNetworkParams.hpp index 04a073311d..5ef2b6ea7c 100644 --- a/tests/ExecuteNetwork/ExecuteNetworkParams.hpp +++ b/tests/ExecuteNetwork/ExecuteNetworkParams.hpp @@ -25,6 +25,7 @@ struct ExecuteNetworkParams TfliteInterpreter }; + bool m_AllowExpandedDims; std::string m_CachedNetworkFilePath; std::vector m_ComputeDevices; bool m_Concurrent; diff --git a/tests/ExecuteNetwork/ExecuteNetworkProgramOptions.cpp b/tests/ExecuteNetwork/ExecuteNetworkProgramOptions.cpp index c84c79ea78..ad35092c1d 100644 --- a/tests/ExecuteNetwork/ExecuteNetworkProgramOptions.cpp +++ b/tests/ExecuteNetwork/ExecuteNetworkProgramOptions.cpp @@ -228,6 +228,13 @@ ProgramOptions::ProgramOptions() : m_CxxOptions{"ExecuteNetwork", "parser)", cxxopts::value(m_ExNetParams.m_InferOutputShape)->default_value("false")->implicit_value("true")) + ("allow-expanded-dims", + "If true will disregard dimensions with a size of 1 when validating tensor shapes. Tensor sizes must " + "still match. This is an Experimental parameter that is incompatible with infer-output-shape. " + "This parameter may be removed in a later update. ", + cxxopts::value(m_ExNetParams.m_AllowExpandedDims)->default_value("false") + ->implicit_value("true")) + ("iterations", "Number of iterations to run the network for, default is set to 1. " "If you wish to run the model with different input data for every execution you can do so by " diff --git a/tests/InferenceModel.hpp b/tests/InferenceModel.hpp index e2a1a97568..93716e1a6f 100644 --- a/tests/InferenceModel.hpp +++ b/tests/InferenceModel.hpp @@ -95,6 +95,7 @@ struct Params std::vector m_ComputeDevices; std::string m_DynamicBackendsPath; size_t m_SubgraphId; + bool m_AllowExpandedDims; bool m_IsModelBinary; bool m_VisualizePostOptimizationModel; bool m_EnableFp16TurboMode; @@ -117,6 +118,7 @@ struct Params Params() : m_ComputeDevices{} , m_SubgraphId(0) + , m_AllowExpandedDims(false) , m_IsModelBinary(true) , m_VisualizePostOptimizationModel(false) , m_EnableFp16TurboMode(false) @@ -268,6 +270,7 @@ public: // Create a network from a file on disk IParser::TfLiteParserOptions options; + options.m_AllowExpandedDims = params.m_AllowExpandedDims; options.m_StandInLayerForUnsupported = params.m_ParseUnsupported; options.m_InferAndValidate = params.m_InferOutputShape; auto parser(IParser::Create(options)); -- cgit v1.2.1