From 4d1ff588288b1a7a98dd2fd7f2ba5717b8ecf102 Mon Sep 17 00:00:00 2001 From: James Conroy Date: Mon, 10 Jun 2019 17:06:39 +0100 Subject: IVGCVSW-3221 Refactor Mean ref workload and tests * Renamed RefMeanFloat32Workload and RefMeanUint8Workload to RefMeanWorkload, updated references to reflect this change. * Refactored RefFloorWorkload to use Decoders/Encoders, to support the use of multiple data types. * Deleted reference Unit8 Mean tests as they were duplicates of the Float32 tests. Refactored these tests to support multiple data types and updated references. * Adjusted the values used in the tests' input tensors so that they are more like floating point numbers e.g. change 1.0f to 1.5f. * Replace size_t with unsigned int in Mean ref workload, for better compatibility with the Encoder/Decoder, removed some unnecessary casts after this. * Added ValidateTensorDataTypesMatch() function to WorkloadData.cpp, added CreateIncorrectDimensionsErrorMsg function to RefLayerSupport.cpp. * Added passing and failing tests for ref IsMeanSupported. Signed-off-by: James Conroy Change-Id: Id3d44463d1385255c727a497d4026d21a49e7eb2 --- src/backends/backendsCommon/WorkloadData.cpp | 39 +++- .../test/IsLayerSupportedTestImpl.hpp | 29 +++ src/backends/backendsCommon/test/LayerTests.cpp | 231 --------------------- src/backends/backendsCommon/test/LayerTests.hpp | 203 +++++++++++++++--- 4 files changed, 238 insertions(+), 264 deletions(-) (limited to 'src/backends/backendsCommon') diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp index a1d00c6945..1505078b77 100644 --- a/src/backends/backendsCommon/WorkloadData.cpp +++ b/src/backends/backendsCommon/WorkloadData.cpp @@ -271,6 +271,20 @@ void ValidateDataTypes(const TensorInfo& info, } } +//--------------------------------------------------------------- +void ValidateTensorDataTypesMatch(const TensorInfo& first, + const TensorInfo& second, + std::string const& descName, + std::string const& firstName, + std::string const& secondName) +{ + if (first.GetDataType() != second.GetDataType()) + { + throw InvalidArgumentException(descName + ": " + firstName + " & " + secondName + + " must have identical data types."); + } +} + } //namespace void QueueDescriptor::ValidateInputsOutputs(const std::string& descName, @@ -1275,25 +1289,40 @@ void MaximumQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const void MeanQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const { - ValidateNumInputs(workloadInfo, "MeanQueueDescriptor", 1); - ValidateNumOutputs(workloadInfo, "MeanQueueDescriptor", 1); + const std::string meanQueueDescString = "MeanQueueDescriptor"; + + ValidateNumInputs(workloadInfo, meanQueueDescString, 1); + ValidateNumOutputs(workloadInfo, meanQueueDescString, 1); + + std::vector supportedTypes = + { + DataType::Float32, + DataType::Float16, + DataType::QuantisedAsymm8, + DataType::QuantisedSymm16 + }; const TensorInfo& input = workloadInfo.m_InputTensorInfos[0]; const TensorInfo& output = workloadInfo.m_OutputTensorInfos[0]; + // First check if input tensor data type is supported, then + // check if this data type matches the output tensor data type + ValidateDataTypes(input, supportedTypes, meanQueueDescString); + ValidateTensorDataTypesMatch(input, output, meanQueueDescString, "input", "output"); + if (m_Parameters.m_KeepDims) { - ValidateTensorNumDimensions(output, "MeanQueueDescriptor", input.GetNumDimensions(), "output"); + ValidateTensorNumDimensions(output, meanQueueDescString, input.GetNumDimensions(), "output"); } else if (m_Parameters.m_Axis.empty()) { - ValidateTensorNumDimensions(output, "MeanQueueDescriptor", 1, "output"); + ValidateTensorNumDimensions(output, meanQueueDescString, 1, "output"); } else { auto outputDim = input.GetNumDimensions() - boost::numeric_cast(m_Parameters.m_Axis.size()); ValidateTensorNumDimensions(output, - "MeanQueueDescriptor", + meanQueueDescString, outputDim > 0 ? outputDim : 1, "output"); } diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index fa6ec1000b..ff632fc701 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -633,5 +633,34 @@ bool IsMeanLayerSupportedTests(std::string& reasonIfUnsupported) return result; } +// Tests that IsMeanSupported fails when input tensor dimensions +// do not match output tensor dimensions when keepDims == true +template +bool IsMeanLayerNotSupportedTests(std::string& reasonIfUnsupported) +{ + armnn::Graph graph; + static const std::vector axes = {}; + // Set keepDims == true + armnn::MeanDescriptor desc(axes, true); + + armnn::Layer* const layer = graph.AddLayer(desc, "LayerName"); + + armnn::Layer* const input = graph.AddLayer(0, "input"); + armnn::Layer* const output = graph.AddLayer(0, "output"); + + // Mismatching number of tensor dimensions + armnn::TensorInfo inputTensorInfo({1, 1, 1, 1}, InputDataType); + armnn::TensorInfo outputTensorInfo({1, 1}, OutputDataType); + + input->GetOutputSlot(0).Connect(layer->GetInputSlot(0)); + input->GetOutputHandler(0).SetTensorInfo(inputTensorInfo); + layer->GetOutputSlot(0).Connect(output->GetInputSlot(0)); + layer->GetOutputHandler(0).SetTensorInfo(outputTensorInfo); + + bool result = FactoryType::IsLayerSupported(*layer, InputDataType, reasonIfUnsupported); + + return result; +} + } //namespace diff --git a/src/backends/backendsCommon/test/LayerTests.cpp b/src/backends/backendsCommon/test/LayerTests.cpp index 9d40197776..55e799e1be 100644 --- a/src/backends/backendsCommon/test/LayerTests.cpp +++ b/src/backends/backendsCommon/test/LayerTests.cpp @@ -8368,237 +8368,6 @@ LayerTestResult PermuteFloat32ValueSet3Test( return PermuteFloat32ValueSet3TestCommon(workloadFactory, memoryManager); }; -namespace -{ - -template -LayerTestResult MeanTestHelper( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, - const unsigned int* inputShape, - const std::vector& inputData, - const std::vector& axis, - bool keepDims, - const unsigned int* outputShape, - const std::vector& outputData, - float scale = 1.0f, - int32_t offset = 0) -{ - auto dataType = (std::is_same::value ? armnn::DataType::QuantisedAsymm8 : armnn::DataType::Float32); - - armnn::TensorInfo inputTensorInfo(InputDim, inputShape, dataType); - armnn::TensorInfo outputTensorInfo(OutputDim, outputShape, dataType); - - inputTensorInfo.SetQuantizationScale(scale); - inputTensorInfo.SetQuantizationOffset(offset); - - outputTensorInfo.SetQuantizationScale(scale); - outputTensorInfo.SetQuantizationOffset(offset); - - auto input = MakeTensor(inputTensorInfo, inputData); - - LayerTestResult result(outputTensorInfo); - result.outputExpected = MakeTensor(outputTensorInfo, outputData); - - std::unique_ptr inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo); - std::unique_ptr outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo); - - armnn::MeanQueueDescriptor data; - data.m_Parameters.m_Axis = axis; - data.m_Parameters.m_KeepDims = keepDims; - armnn::WorkloadInfo info; - AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get()); - AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); - - std::unique_ptr workload = workloadFactory.CreateMean(data, info); - - inputHandle->Allocate(); - outputHandle->Allocate(); - - CopyDataToITensorHandle(inputHandle.get(), input.origin()); - - workload->PostAllocationConfigure(); - workload->Execute(); - - CopyDataFromITensorHandle(result.output.origin(), outputHandle.get()); - - return result; -} - -} // anonymous namespace - -LayerTestResult MeanUint8SimpleTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 3, 2 }; - const unsigned int outputShape[] = { 1 }; - - std::vector input({ 1, 1, 2, 2, 3, 3 }); - std::vector output({ 2 }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output); -} - -LayerTestResult MeanUint8SimpleAxisTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 1, 1, 3, 2 }; - const unsigned int outputShape[] = { 1, 1, 2 }; - - std::vector input({ 1, 1, 2, 2, 3, 3 }); - std::vector output({ 2, 2 }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output); -} - -LayerTestResult MeanUint8KeepDimsTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 1, 1, 3, 2 }; - const unsigned int outputShape[] = { 1, 1, 1, 2 }; - - std::vector input({ 1, 1, 2, 2, 3, 3 }); - std::vector output({ 2, 2 }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output); -} - -LayerTestResult MeanUint8MultipleDimsTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 2, 3, 1, 2 }; - const unsigned int outputShape[] = { 1, 3, 1, 1 }; - - std::vector input({ 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6 }); - std::vector output({ 1, 3, 5 }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output); -} - -LayerTestResult MeanVtsUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 4, 3, 2 }; - const unsigned int outputShape[] = { 2 }; - - std::vector input({ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24 }); - std::vector output({ 12, 13 }); - - return MeanTestHelper(workloadFactory, memoryManager, - inputShape, input, { 0, 1 }, false, outputShape, - output, 0.8f, 5); -} - -LayerTestResult MeanFloatSimpleTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 3, 2 }; - const unsigned int outputShape[] = { 1 }; - - std::vector input({ 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f }); - std::vector output({ 2.0f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output); -} - -LayerTestResult MeanFloatSimpleAxisTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 2, 3, 1, 2 }; - const unsigned int outputShape[] = { 3, 1, 2 }; - - std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f }); - std::vector output({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 0 }, false, outputShape, output); -} - -LayerTestResult MeanFloatKeepDimsTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 1, 1, 3, 2 }; - const unsigned int outputShape[] = { 1, 1, 1, 2 }; - - std::vector input({ 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f }); - std::vector output({ 2.0f, 2.0f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output); -} - -LayerTestResult MeanFloatMultipleDimsTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 2, 3, 1, 2 }; - const unsigned int outputShape[] = { 1, 3, 1, 1 }; - - std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f }); - std::vector output({ 1.5f, 3.5f, 5.5f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output); -} - -LayerTestResult MeanVtsFloat1Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 4, 3, 2 }; - const unsigned int outputShape[] = { 2 }; - - std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, - 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f }); - std::vector output({ 12.0f, 13.0f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 0, 1 }, false, outputShape, output); -} - -LayerTestResult MeanVtsFloat2Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 4, 3, 2 }; - const unsigned int outputShape[] = { 1, 3, 1 }; - - std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, - 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f }); - std::vector output({ 10.5f, 12.5f, 14.5f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 0, 2 }, true, outputShape, output); -} - -LayerTestResult MeanVtsFloat3Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) -{ - const unsigned int inputShape[] = { 1, 2, 2, 1 }; - const unsigned int outputShape[] = { 1, 2, 1 }; - - std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f }); - std::vector output({ 1.5f, 3.5f }); - - return MeanTestHelper( - workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output); -} - LayerTestResult AdditionAfterMaxPoolTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index 3eed189c1b..fab1ad83c1 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -1448,51 +1448,38 @@ LayerTestResult MaximumBroadcast1DVectorInt16Test( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanUint8SimpleTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult MeanUint8SimpleAxisTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult MeanUint8KeepDimsTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult MeanUint8MultipleDimsTest( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult MeanVtsUint8Test( - armnn::IWorkloadFactory& workloadFactory, - const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); - -LayerTestResult MeanFloatSimpleTest( +template> +LayerTestResult MeanSimpleTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanFloatSimpleAxisTest( +template> +LayerTestResult MeanSimpleAxisTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanFloatKeepDimsTest( +template> +LayerTestResult MeanKeepDimsTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanFloatMultipleDimsTest( +template> +LayerTestResult MeanMultipleDimsTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanVtsFloat1Test( +template> +LayerTestResult MeanVts1Test( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanVtsFloat2Test( +template> +LayerTestResult MeanVts2Test( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); -LayerTestResult MeanVtsFloat3Test( +template> +LayerTestResult MeanVts3Test( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); @@ -2912,4 +2899,164 @@ template LayerTestResult( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, - const armnn::DataLayout dataLayout); \ No newline at end of file + const armnn::DataLayout dataLayout); + +template +LayerTestResult MeanTestHelper( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const unsigned int* inputShape, + const std::vector& inputData, + const std::vector& axis, + bool keepDims, + const unsigned int* outputShape, + const std::vector& outputData, + float scale = 1.0f, + int32_t offset = 0) +{ + armnn::TensorInfo inputTensorInfo(InputDim, inputShape, ArmnnType); + armnn::TensorInfo outputTensorInfo(OutputDim, outputShape, ArmnnType); + + inputTensorInfo.SetQuantizationScale(scale); + inputTensorInfo.SetQuantizationOffset(offset); + + outputTensorInfo.SetQuantizationScale(scale); + outputTensorInfo.SetQuantizationOffset(offset); + + auto input = MakeTensor(inputTensorInfo, ConvertToDataType(inputData, inputTensorInfo)); + + LayerTestResult result(outputTensorInfo); + result.outputExpected = MakeTensor( + outputTensorInfo, ConvertToDataType(outputData, outputTensorInfo)); + + std::unique_ptr inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo); + std::unique_ptr outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo); + + armnn::MeanQueueDescriptor data; + data.m_Parameters.m_Axis = axis; + data.m_Parameters.m_KeepDims = keepDims; + armnn::WorkloadInfo info; + AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get()); + AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); + + std::unique_ptr workload = workloadFactory.CreateMean(data, info); + + inputHandle->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle.get(), input.origin()); + + workload->PostAllocationConfigure(); + workload->Execute(); + + CopyDataFromITensorHandle(result.output.origin(), outputHandle.get()); + + return result; +} + +template +LayerTestResult MeanSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 3, 2 }; + const unsigned int outputShape[] = { 1 }; + + std::vector input({ 1.5f, 1.5f, 2.5f, 2.5f, 3.5f, 3.5f }); + std::vector output({ 2.5f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output); +} + +template +LayerTestResult MeanSimpleAxisTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 2, 3, 1, 2 }; + const unsigned int outputShape[] = { 3, 1, 2 }; + + std::vector input({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f }); + std::vector output({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, { 0 }, false, outputShape, output); +} + +template +LayerTestResult MeanKeepDimsTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 1, 1, 3, 2 }; + const unsigned int outputShape[] = { 1, 1, 1, 2 }; + + std::vector input({ 1.5f, 1.5f, 2.5f, 2.5f, 3.5f, 3.5f }); + std::vector output({ 2.5f, 2.5f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output); +} + +template +LayerTestResult MeanMultipleDimsTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 2, 3, 1, 2 }; + const unsigned int outputShape[] = { 1, 3, 1, 1 }; + + std::vector input({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5 }); + std::vector output({ 2.0f, 4.0f, 6.0f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output); +} + +template +LayerTestResult MeanVts1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 4, 3, 2 }; + const unsigned int outputShape[] = { 2 }; + + std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, + 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f }); + std::vector output({ 12.0f, 13.0f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, { 0, 1 }, false, outputShape, output); +} + +template +LayerTestResult MeanVts2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 4, 3, 2 }; + const unsigned int outputShape[] = { 1, 3, 1 }; + + std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, + 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f }); + std::vector output({ 10.5f, 12.5f, 14.5f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, { 0, 2 }, true, outputShape, output); +} + +template +LayerTestResult MeanVts3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int inputShape[] = { 1, 2, 2, 1 }; + const unsigned int outputShape[] = { 1, 2, 1 }; + + std::vector input({ 1.0f, 2.0f, 3.0f, 4.0f }); + std::vector output({ 1.5f, 3.5f }); + + return MeanTestHelper( + workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output); +} -- cgit v1.2.1