From d905decd256558bbee165e636ce4242ac3b9c917 Mon Sep 17 00:00:00 2001 From: Matthew Sloyan Date: Mon, 3 May 2021 12:22:03 +0100 Subject: MLCE-418 Reduce layer does not support multiple axes * Added backend specific optimization to chain new reduces layers for each axis to simulate behaviour of a layer with multiple axes. * Added function to calculate reduced output shape. * Added unit tests. Signed-off-by: Matthew Sloyan Change-Id: I180b0b111b7bcf3d0c283f1db0b82d5f17757682 --- src/backends/aclCommon/ArmComputeSubgraphUtils.hpp | 85 ++++++++++++++++++++++ src/backends/aclCommon/ArmComputeUtils.hpp | 55 ++++++++++++++ 2 files changed, 140 insertions(+) (limited to 'src/backends/aclCommon') diff --git a/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp b/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp index a0fca46330..9439ddb61e 100644 --- a/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp +++ b/src/backends/aclCommon/ArmComputeSubgraphUtils.hpp @@ -6,6 +6,9 @@ #pragma once #include +#include + +#include namespace armnn { @@ -147,4 +150,86 @@ LayerType* FuseLayerWithWeightsAndBiases(OptimizationViews& optimizationViews, return replacementLayer; } +// +// If reduce layer has multiple axes, add new layer for each axis to simulate the same behaviour +// as currently only one axis is supported. +// +template +void ChainReduceLayers(OptimizationViews& optimizationViews, + LayerType* baseLayer, + ReduceDescriptor& reduceDescriptor) +{ + // If layer has single axis don't chain layers. + if (!reduceDescriptor.m_vAxis.empty() && reduceDescriptor.m_vAxis.size() > 1) + { + // Save base layer output shape to compare against the output of the final layer added. + const TensorInfo baseLayerInfo = baseLayer->GetOutputSlot(0).GetTensorInfo(); + + // Vector of new chained layers, used for substitution. + std::vector layers; + + // Vector of axes so each layer is reshaped correctly. + std::vector reduceAxis; + unsigned int recalulateAxis = 0; + + for (unsigned int i = 0; i != reduceDescriptor.m_vAxis.size(); ++i) + { + // Get TensorInfo to populate subsequent layers with. + TensorInfo layerInfoToModify = baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(); + + reduceAxis.emplace_back(reduceDescriptor.m_vAxis[i]); + + // Calculate new shape based on the axes. + const TensorShape& reducedShape = ComputeReductionTensorShape(layerInfoToModify, + reduceAxis, + reduceDescriptor.m_KeepDims); + layerInfoToModify.SetShape(reducedShape); + + // Create a vector for the single axis to be assigned to the descriptor. + // Update axis if keepDims is set reduce layers correctly. + std::vector singleAxis(1, reduceDescriptor.m_vAxis[i] - recalulateAxis); + + // Create a descriptor and assign single axis. + ReduceDescriptor newReduceDescriptor = baseLayer->GetParameters(); + newReduceDescriptor.m_vAxis.assign(singleAxis.begin(), singleAxis.end()); + + // Add new layer to graph. + std::string layerName = "reduce_layer_" + std::to_string(i); + Layer* replacementLayer = optimizationViews.GetGraph().AddLayer(newReduceDescriptor, + layerName.c_str()); + + // Connect previous layer with new layer. + // The first and last layer will be connected when the subgraph is replaced. + if (!layers.empty()) + { + layers[i - 1]->GetOutputSlot(0).Connect(replacementLayer->GetInputSlot(0)); + } + + // Set updated tensorInfo for new layer. + replacementLayer->GetOutputSlot(0).SetTensorInfo(layerInfoToModify); + + if (!reduceDescriptor.m_KeepDims) + { + recalulateAxis++; + } + + layers.emplace_back(replacementLayer); + } + + // Check if the TensorInfo from the last layer equals the inferred output from the original layer. + ARMNN_ASSERT(baseLayerInfo == layers.back()->GetOutputSlot().GetTensorInfo()); + + std::list replacementLayers(layers.begin(), layers.end()); + + // Substitute new chained subgraph for original reduce layer. + SubgraphView substitutionSubgraph(baseLayer); + SubgraphView replacementSubgraph(CreateInputsFrom({replacementLayers.front()}), + CreateOutputsFrom({replacementLayers.back()}), + std::move(replacementLayers)); + + optimizationViews.AddSubstitution({substitutionSubgraph, replacementSubgraph}); + + } +} + } // namespace armnn diff --git a/src/backends/aclCommon/ArmComputeUtils.hpp b/src/backends/aclCommon/ArmComputeUtils.hpp index d9efab288f..5bc5abcb05 100644 --- a/src/backends/aclCommon/ArmComputeUtils.hpp +++ b/src/backends/aclCommon/ArmComputeUtils.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include @@ -267,4 +268,58 @@ inline arm_compute::ReductionOperation ConvertReductionOperationToAcl(const Redu } } +/// Function to compute the output tensor shape based on the axes and if keepDims is set. +inline const TensorShape ComputeReductionTensorShape(const armnn::TensorInfo& input, + const std::vector& vAxis, + const bool keepDims) +{ + unsigned int rank = input.GetNumDimensions(); + unsigned int outputRank = 0; + + // Calculate output dimension + if (keepDims) + { + outputRank = rank; + } + else if (vAxis.empty()) + { + outputRank = 1; + } + else if (vAxis.size() > input.GetNumDimensions()) + { + throw LayerValidationException("ReduceLayer: Dimensions to reduce can not be bigger than input dimensions"); + } + else + { + outputRank = input.GetNumDimensions() - armnn::numeric_cast(vAxis.size()); + if (outputRank == 0) + { + outputRank = 1; + } + } + + std::vector dimSizes(outputRank, 1); + if (!vAxis.empty()) + { + // Skip the dimension that has been reduced unless keepDims is true. + unsigned int outputIndex = 0; + for (unsigned int i = 0; i < input.GetNumDimensions(); ++i) + { + if (std::find(vAxis.begin(), vAxis.end(), i) == vAxis.end()) + { + dimSizes[outputIndex] = armnn::numeric_cast(input.GetShape()[i]); + ++outputIndex; + } + else if (keepDims) + { + dimSizes[outputIndex] = 1; + ++outputIndex; + } + } + } + + const TensorShape inferredShape = TensorShape(outputRank, dimSizes.data()); + return inferredShape; +} + } // namespace armnn -- cgit v1.2.1