IVGCVSW-7606 IVGCVSW-7607 Add Resize and Reduce to Opaque Delegate
* Added 2 opaque delegate operators and associated test cases
* Removed IsDynamicTensor check from BatchMatMul as covered by IsValid.
Signed-off-by: John Mcloughlin <john.mcloughlin@arm.com>
Change-Id: If7c58cb23ae5c5b8a9451dddfd7b6dfcbf248d4c
diff --git a/delegate/opaque/CMakeLists.txt b/delegate/opaque/CMakeLists.txt
index ac205ee..897263d 100644
--- a/delegate/opaque/CMakeLists.txt
+++ b/delegate/opaque/CMakeLists.txt
@@ -28,6 +28,8 @@
src/Pack.hpp
src/Prelu.hpp
src/Redefine.hpp
+ src/Reduce.hpp
+ src/Resize.hpp
src/Round.hpp
src/Shape.hpp
src/SharedFunctions.cpp
diff --git a/delegate/opaque/src/BatchMatMul.hpp b/delegate/opaque/src/BatchMatMul.hpp
index 5da6e5a..5261fbd 100644
--- a/delegate/opaque/src/BatchMatMul.hpp
+++ b/delegate/opaque/src/BatchMatMul.hpp
@@ -44,15 +44,6 @@
return kTfLiteError;
}
- if (IsDynamicTensor(kTfLiteLHSInputTensor) || IsDynamicTensor(kTfLiteRHSInputTensor))
- {
- TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
- tfLiteContext,
- "TfLiteArmnnOpaqueDelegate: Dynamic input tensors are not supported in operator #%d node #%d: ",
- operatorCode, nodeIndex);
- return kTfLiteError;
- }
-
// Gather output indices and use to get output tensors.
int numOutputs = 0;
const int* outputTensors;
diff --git a/delegate/opaque/src/Reduce.hpp b/delegate/opaque/src/Reduce.hpp
index e169697..afea7aa 100644
--- a/delegate/opaque/src/Reduce.hpp
+++ b/delegate/opaque/src/Reduce.hpp
@@ -2,3 +2,166 @@
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
+#pragma once
+
+#include <OpaqueDelegateUtils.hpp>
+
+namespace armnnOpaqueDelegate
+{
+
+TfLiteStatus VisitReduceOperator(DelegateData& delegateData,
+ TfLiteOpaqueContext* tfLiteContext,
+ TfLiteOpaqueNode* tfLiteNode,
+ int nodeIndex,
+ int32_t reduceOperatorCode)
+{
+ TF_LITE_ENSURE_STATUS(ValidateNumInputs(tfLiteContext, tfLiteNode, 2, nodeIndex));
+ TF_LITE_ENSURE_STATUS(ValidateNumOutputs(tfLiteContext, tfLiteNode, 1, nodeIndex));
+
+ // Gather input indices and use to get input tensor.
+ auto numInputs = TfLiteOpaqueNodeNumberOfInputs(tfLiteNode);
+ const int* inputTensors;
+ if (TfLiteOpaqueNodeInputs(tfLiteNode, &inputTensors, &numInputs) != kTfLiteOk)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Unable to gather input tensor indices from node #%d: ",
+ nodeIndex);
+ return kTfLiteError;
+ }
+
+ const TfLiteOpaqueTensor* tfLiteInputTensor =
+ TfLiteOpaqueContextGetOpaqueTensor(tfLiteContext, inputTensors[0]);
+ if (!IsValid(tfLiteContext, tfLiteInputTensor, reduceOperatorCode, nodeIndex))
+ {
+ return kTfLiteError;
+ }
+
+ const TfLiteOpaqueTensor* tfLiteAxisTensor =
+ TfLiteOpaqueContextGetOpaqueTensor(tfLiteContext, inputTensors[1]);
+ if (!IsValid(tfLiteContext, tfLiteAxisTensor, reduceOperatorCode, nodeIndex))
+ {
+ return kTfLiteError;
+ }
+
+ // Gather output indices and use to get output tensors.
+ int numOutputs = 0;
+ const int* outputTensors;
+ if (TfLiteOpaqueNodeOutputs(tfLiteNode, &outputTensors, &numOutputs) != kTfLiteOk)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Unable to gather output tensor indices from node #%d: ",
+ nodeIndex);
+ return kTfLiteError;
+ }
+
+ const TfLiteOpaqueTensor* tfLiteOutputTensor =
+ TfLiteOpaqueContextGetOpaqueTensor(tfLiteContext, outputTensors[0]);
+ if (!IsValid(tfLiteContext, tfLiteOutputTensor, reduceOperatorCode, nodeIndex))
+ {
+ return kTfLiteError;
+ }
+
+ const armnn::TensorInfo& inputTensorInfo = GetTensorInfoForTfLiteOpaqueTensor(tfLiteInputTensor);
+ const armnn::TensorInfo& outputTensorInfo = GetTensorInfoForTfLiteOpaqueTensor(tfLiteOutputTensor, true);
+
+ // Get const axis value from model and set it to descriptor.
+ const armnn::TensorInfo& axisTensorInfo = GetTensorInfoForTfLiteOpaqueTensor(tfLiteAxisTensor);
+ auto* axisTensorData = static_cast<int*>(TfLiteOpaqueTensorData(tfLiteAxisTensor));
+
+ std::vector<int32_t> axis;
+ // Add axis data to vector to be converter to unsigned int and assigned to descriptor axis.
+ if (axisTensorData != nullptr)
+ {
+ for (unsigned int i = 0; i < axisTensorInfo.GetNumElements(); ++i)
+ {
+ axis.emplace_back(axisTensorData[i]);
+ }
+ }
+ else
+ {
+ for (unsigned int i = 0; i < inputTensorInfo.GetNumDimensions(); ++i)
+ {
+ axis.push_back(i);
+ }
+ }
+
+ // Convert the axis to unsigned int and remove duplicates.
+ unsigned int rank = inputTensorInfo.GetNumDimensions();
+ std::set<unsigned int> uniqueAxis;
+ std::transform(axis.begin(),
+ axis.end(),
+ std::inserter(uniqueAxis, uniqueAxis.begin()),
+ [rank](int i)->unsigned int{ return (i + rank) % rank; });
+
+ armnn::ReduceDescriptor desc;
+ desc.m_vAxis.assign(uniqueAxis.begin(), uniqueAxis.end());
+
+ auto* reducerParameters = reinterpret_cast<TfLiteReducerParams*>(TfLiteOpaqueNodeGetBuiltinData(tfLiteNode));
+ desc.m_KeepDims = reducerParameters->keep_dims;
+ if (reduceOperatorCode == kTfLiteBuiltinReduceMax)
+ {
+ desc.m_ReduceOperation = armnn::ReduceOperation::Max;
+ }
+ else if (reduceOperatorCode == kTfLiteBuiltinReduceMin)
+ {
+ desc.m_ReduceOperation = armnn::ReduceOperation::Min;
+ }
+ else if (reduceOperatorCode == kTfLiteBuiltinSum)
+ {
+ desc.m_ReduceOperation = armnn::ReduceOperation::Sum;
+ }
+ else if (reduceOperatorCode == kTfLiteBuiltinReduceProd)
+ {
+ desc.m_ReduceOperation = armnn::ReduceOperation::Prod;
+ }
+ else
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Unsupported Reduction Operator #%d node #%d: ",
+ reduceOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+
+ bool isSupported = false;
+ armnn::BackendId setBackend;
+ auto validateFunc = [&](const armnn::TensorInfo& outInfo, bool& isSupported)
+ {
+ FORWARD_LAYER_OPAQUE_SUPPORT_FUNC("REDUCE",
+ tfLiteContext,
+ IsReduceSupported,
+ delegateData.m_Backends,
+ isSupported,
+ setBackend,
+ inputTensorInfo,
+ outInfo,
+ desc);
+ };
+
+ if (!delegateData.m_Network)
+ {
+ validateFunc(outputTensorInfo, isSupported);
+ return isSupported ? kTfLiteOk : kTfLiteError;
+ }
+
+ // Add an Reduce layer
+ armnn::IConnectableLayer* layer = delegateData.m_Network->AddReduceLayer(desc);
+ layer->SetBackendId(setBackend);
+ ARMNN_ASSERT(layer != nullptr);
+
+ armnn::IOutputSlot& outputSlot = layer->GetOutputSlot(0);
+ outputSlot.SetTensorInfo(outputTensorInfo);
+
+ // try to connect the Constant Inputs if there are any
+ if(ProcessInputs(layer,delegateData, tfLiteContext, tfLiteNode) != kTfLiteOk )
+ {
+ return kTfLiteError;
+ }
+
+ // Connect
+ return Connect(layer, tfLiteContext, tfLiteNode, delegateData);
+}
+
+} // namespace armnnOpaqueDelegate
diff --git a/delegate/opaque/src/Resize.hpp b/delegate/opaque/src/Resize.hpp
index e169697..509ae62 100644
--- a/delegate/opaque/src/Resize.hpp
+++ b/delegate/opaque/src/Resize.hpp
@@ -2,3 +2,221 @@
// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
+
+#pragma once
+
+#include <OpaqueDelegateUtils.hpp>
+
+namespace armnnOpaqueDelegate
+{
+
+TfLiteStatus ValidateResizeOperator(DelegateData& delegateData,
+ TfLiteOpaqueContext* tfLiteContext,
+ const armnn::TensorInfo& inputInfo,
+ const armnn::TensorInfo& outputInfo,
+ const armnn::ResizeDescriptor& descriptor)
+{
+ bool isSupported = false;
+ FORWARD_LAYER_OPAQUE_SUPPORT_FUNC("RESIZE",
+ tfLiteContext,
+ IsResizeSupported,
+ delegateData.m_Backends,
+ isSupported,
+ armnn::BackendId(),
+ inputInfo,
+ outputInfo,
+ descriptor);
+
+ return isSupported ? kTfLiteOk : kTfLiteError;
+}
+
+TfLiteStatus VisitResizeOperator(DelegateData& delegateData,
+ TfLiteOpaqueContext* tfLiteContext,
+ TfLiteOpaqueNode* tfLiteNode,
+ int nodeIndex,
+ int32_t resizeOperatorCode)
+{
+ TF_LITE_ENSURE_STATUS(ValidateNumInputs(tfLiteContext, tfLiteNode, 2, nodeIndex));
+ TF_LITE_ENSURE_STATUS(ValidateNumOutputs(tfLiteContext, tfLiteNode, 1, nodeIndex));
+
+ // Gather input indices and use to get input tensor.
+ auto numInputs = TfLiteOpaqueNodeNumberOfInputs(tfLiteNode);
+ const int* inputTensors;
+ if (TfLiteOpaqueNodeInputs(tfLiteNode, &inputTensors, &numInputs) != kTfLiteOk)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Unable to gather input tensor indices from node #%d: ",
+ nodeIndex);
+ return kTfLiteError;
+ }
+
+ // The first input contains the data of the image that should be resized [batch, height, width, channels]
+ const TfLiteOpaqueTensor* tfLiteInputTensor =
+ TfLiteOpaqueContextGetOpaqueTensor(tfLiteContext, inputTensors[0]);
+ if (IsDynamicTensor(tfLiteInputTensor))
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Dynamic input tensors are not supported in operator #%d node #%d: ",
+ resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+
+ // The second input contains a size tensor. The size tensor contains two integer values
+ // that describe the new height and width of the image [new_height, new_width]
+ const TfLiteOpaqueTensor* tfLiteSizeTensor =
+ TfLiteOpaqueContextGetOpaqueTensor(tfLiteContext, inputTensors[1]);
+ if (IsDynamicTensor(tfLiteSizeTensor))
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Dynamic input tensors are not supported in operator #%d node #%d: ",
+ resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+
+ // Gather output indices and use to get output tensors.
+ int numOutputs = 0;
+ const int* outputTensors;
+ if (TfLiteOpaqueNodeOutputs(tfLiteNode, &outputTensors, &numOutputs) != kTfLiteOk)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Unable to gather output tensor indices from node #%d: ",
+ nodeIndex);
+ return kTfLiteError;
+ }
+
+ // The output tensor should have the shape [batch, new_height, new_width, channels]
+ const TfLiteOpaqueTensor* tfLiteOutputTensor =
+ TfLiteOpaqueContextGetOpaqueTensor(tfLiteContext, outputTensors[0]);
+ if (IsDynamicTensor(tfLiteOutputTensor))
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Dynamic output tensors are not supported in operator #%d node #%d: ",
+ resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+
+ const armnn::TensorInfo& inputTensorInfo =
+ GetTensorInfoForTfLiteOpaqueTensor(tfLiteInputTensor);
+ const armnn::TensorInfo& outputTensorInfo =
+ GetTensorInfoForTfLiteOpaqueTensor(tfLiteOutputTensor, true);
+
+ std::string layerName("Resize");
+
+ // Fill descriptor
+ armnn::ResizeDescriptor desc;
+ switch (resizeOperatorCode)
+ {
+ case kTfLiteBuiltinResizeBilinear:
+ {
+ desc.m_Method = armnn::ResizeMethod::Bilinear;
+
+ layerName += "Bilinear:" + std::to_string(nodeIndex);
+
+ TfLiteResizeBilinearParams* bilinearOptions =
+ reinterpret_cast<TfLiteResizeBilinearParams*>(TfLiteOpaqueNodeGetBuiltinData(tfLiteNode));
+
+ desc.m_AlignCorners = bilinearOptions->align_corners;
+ desc.m_HalfPixelCenters = bilinearOptions->half_pixel_centers;
+ break;
+ }
+ case kTfLiteBuiltinResizeNearestNeighbor:
+ {
+ desc.m_Method = armnn::ResizeMethod::NearestNeighbor;
+ layerName += "NearestNeighbor:" + std::to_string(nodeIndex);
+
+ TfLiteResizeNearestNeighborParams* nearestNeighborOptions =
+ reinterpret_cast<TfLiteResizeNearestNeighborParams*>(TfLiteOpaqueNodeGetBuiltinData(tfLiteNode));
+
+ desc.m_AlignCorners = nearestNeighborOptions->align_corners;
+ desc.m_HalfPixelCenters = nearestNeighborOptions->half_pixel_centers;
+ break;
+ }
+ default:
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: Unknown TfLite built in operation for Resize. "
+ "Given operator: #%d node #%d: ",
+ resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+ }
+
+ // In Arm NN the values of the size input tensor [new_height, new_width] is saved in the operator
+ // descriptor. We have to read it from the input tensor and write it to the descriptor.
+
+ auto* sizeTensorDataPtr = static_cast<int*>(TfLiteOpaqueTensorData(tfLiteSizeTensor));
+ auto sizeTensorNumDimensions = TfLiteOpaqueTensorNumDims(tfLiteSizeTensor);
+ // The size tensor is only a 1D tensor -> [new_height, new width]
+ if (sizeTensorNumDimensions != 1)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: The Size-Input-Tensor of the Resize operation is not allowed to be a "
+ "dynamic tensor. Operator: #%d node #%d: ",
+ resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+
+ // Get number of values in the size tensor
+ auto sizeTensorNumValues = TfLiteOpaqueTensorDim(tfLiteSizeTensor,0);
+ if (sizeTensorNumValues == 0)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: The Size-Input-Tensor of the Resize operation is not allowed to be a "
+ "dynamic tensor. Operator: #%d node #%d: ",
+ resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+ else if (sizeTensorNumValues != 2)
+ {
+ TF_LITE_OPAQUE_MAYBE_KERNEL_LOG(
+ tfLiteContext,
+ "TfLiteArmnnOpaqueDelegate: The Size-Input-Tensor of the Resize operation requires to "
+ "have a dimension of 2 [new_height, new width] but a tensor with a dimension of #%d was given. "
+ "Operator: #%d node #%d: ",
+ sizeTensorNumValues, resizeOperatorCode, nodeIndex);
+ return kTfLiteError;
+ }
+ // get size tensor data
+ std::vector<int32_t> sizeTensorData(sizeTensorDataPtr, sizeTensorDataPtr+sizeTensorNumValues);
+
+ desc.m_TargetHeight = static_cast<uint32_t> (sizeTensorData[0]);
+ desc.m_TargetWidth = static_cast<uint32_t> (sizeTensorData[1]);
+ desc.m_DataLayout = armnn::DataLayout::NHWC;
+
+ // No network pointer indicates that only support for this operator should be checked
+ if (!delegateData.m_Network)
+ {
+ return ValidateResizeOperator(delegateData,
+ tfLiteContext,
+ inputTensorInfo,
+ outputTensorInfo,
+ desc);
+ }
+
+
+ armnn::IConnectableLayer* resizeLayer = nullptr;
+ resizeLayer = delegateData.m_Network->AddResizeLayer(desc, layerName.c_str());
+
+ armnn::IOutputSlot& outputSlot = resizeLayer->GetOutputSlot(0);
+ outputSlot.SetTensorInfo(outputTensorInfo);
+
+ // try to connect the Constant Inputs if there are any
+ if(ProcessInputs(resizeLayer,delegateData, tfLiteContext, tfLiteNode) != kTfLiteOk )
+ {
+ return kTfLiteError;
+ }
+
+ ARMNN_ASSERT(resizeLayer != nullptr);
+
+ return Connect(resizeLayer, tfLiteContext, tfLiteNode, delegateData);
+}
+
+} // namespace armnnOpaqueDelegate
diff --git a/delegate/opaque/src/armnn_delegate.cpp b/delegate/opaque/src/armnn_delegate.cpp
index 9b1c3a1..936e75a 100644
--- a/delegate/opaque/src/armnn_delegate.cpp
+++ b/delegate/opaque/src/armnn_delegate.cpp
@@ -966,6 +966,24 @@
tfLiteNode,
nodeIndex,
kTfLiteBuiltinQuantize);
+ case kTfLiteBuiltinReduceMax:
+ return VisitReduceOperator(delegateData,
+ tfLiteContext,
+ tfLiteNode,
+ nodeIndex,
+ kTfLiteBuiltinReduceMax);
+ case kTfLiteBuiltinReduceMin:
+ return VisitReduceOperator(delegateData,
+ tfLiteContext,
+ tfLiteNode,
+ nodeIndex,
+ kTfLiteBuiltinReduceMin);
+ case kTfLiteBuiltinReduceProd:
+ return VisitReduceOperator(delegateData,
+ tfLiteContext,
+ tfLiteNode,
+ nodeIndex,
+ kTfLiteBuiltinReduceProd);
case kTfLiteBuiltinRelu:
return VisitActivationOperator(delegateData,
tfLiteContext,
@@ -984,6 +1002,18 @@
tfLiteNode,
nodeIndex,
kTfLiteBuiltinRelu6);
+ case kTfLiteBuiltinResizeNearestNeighbor:
+ return VisitResizeOperator(delegateData,
+ tfLiteContext,
+ tfLiteNode,
+ nodeIndex,
+ kTfLiteBuiltinResizeNearestNeighbor);
+ case kTfLiteBuiltinResizeBilinear:
+ return VisitResizeOperator(delegateData,
+ tfLiteContext,
+ tfLiteNode,
+ nodeIndex,
+ kTfLiteBuiltinResizeBilinear);
case kTfLiteBuiltinRsqrt:
return VisitElementwiseUnaryOperator(delegateData,
tfLiteContext,
@@ -1035,6 +1065,12 @@
nodeIndex,
kTfLiteBuiltinSqrt,
armnn::UnaryOperation::Sqrt);
+ case kTfLiteBuiltinSum:
+ return VisitReduceOperator(delegateData,
+ tfLiteContext,
+ tfLiteNode,
+ nodeIndex,
+ kTfLiteBuiltinSum);
case kTfLiteBuiltinTanh:
return VisitActivationOperator(delegateData,
tfLiteContext,