From 988354de127528bdebb98fd25661fbf2f39f17dd Mon Sep 17 00:00:00 2001 From: Tianle Cheng Date: Wed, 28 Jun 2023 13:20:47 +0100 Subject: IVGCVSW-7831: Front end and Reference Implementation for REVERSE_V2 * Descriptors added for ReverseV2 * Layer definition added * Input validation added * Reference workload implementation for ReverseV2 added * Reference layer unit tests made for ReverseV2 * CompareTensors method updated to support comparison between empty tensors * CMake and other build files updated Signed-off-by: Tianle Cheng Change-Id: I805738454421309fda77c44218a8df171d68dc18 --- src/backends/backendsCommon/test/CMakeLists.txt | 2 + .../test/IsLayerSupportedTestImpl.hpp | 2 + src/backends/backendsCommon/test/LayerTests.hpp | 1 + .../test/layerTests/ReverseV2TestImpl.cpp | 1084 ++++++++++++++++++++ .../test/layerTests/ReverseV2TestImpl.hpp | 156 +++ 5 files changed, 1245 insertions(+) create mode 100644 src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp create mode 100644 src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp (limited to 'src/backends/backendsCommon/test') diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt index aba9c72e6c..0139044432 100644 --- a/src/backends/backendsCommon/test/CMakeLists.txt +++ b/src/backends/backendsCommon/test/CMakeLists.txt @@ -170,6 +170,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/ReshapeTestImpl.hpp layerTests/ResizeTestImpl.cpp layerTests/ResizeTestImpl.hpp + layerTests/ReverseV2TestImpl.cpp + layerTests/ReverseV2TestImpl.hpp layerTests/RsqrtTestImpl.cpp layerTests/RsqrtTestImpl.hpp layerTests/SinTestImpl.cpp diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index 182fab97be..f7a852f440 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -744,6 +744,8 @@ DECLARE_LAYER_POLICY_2_PARAM(Resize) DECLARE_LAYER_POLICY_2_PARAM(Reshape) +DECLARE_LAYER_POLICY_2_PARAM(ReverseV2) + DECLARE_LAYER_POLICY_1_PARAM(Shape) DECLARE_LAYER_POLICY_2_PARAM(Slice) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index b6ddb31419..755a665ba6 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -60,6 +60,7 @@ #include #include #include +#include #include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp new file mode 100644 index 0000000000..586b831e45 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp @@ -0,0 +1,1084 @@ +// +// Copyright © 2023 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ReverseV2TestImpl.hpp" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace +{ + template + LayerTestResult ReverseV2TestImpl( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory, + armnn::ReverseV2Descriptor descriptor, + const std::vector& input, + const std::vector& outputExpected, + const armnn::TensorInfo& inputInfo, + const armnn::TensorInfo& outputInfo) + { + LayerTestResult result(outputInfo); + std::vector outputActual(outputInfo.GetNumElements()); + + std::unique_ptr inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo); + std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo); + + armnn::ReverseV2QueueDescriptor queueDescriptor; + queueDescriptor.m_Parameters = std::move(descriptor); + armnn::WorkloadInfo workloadInfo; + + AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get()); + AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get()); + + // Don't execute if ReverseV2 is not supported, as an exception will be raised. + const armnn::BackendId& backend = workloadFactory.GetBackendId(); + std::string reasonIfUnsupported; + armnn::LayerSupportHandle handle = armnn::GetILayerSupportByBackendId(backend); + result.m_Supported = handle.IsReverseV2Supported(inputInfo, + outputInfo, + queueDescriptor.m_Parameters, + reasonIfUnsupported); + if (!result.m_Supported) + { + return result; + } + + auto workload = workloadFactory.CreateWorkload(armnn::LayerType::ReverseV2, queueDescriptor, workloadInfo); + + inputHandle->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle.get(), input.data()); + + workload->PostAllocationConfigure(); + ExecuteWorkload(*workload, memoryManager); + + CopyDataFromITensorHandle(outputActual.data(), outputHandle.get()); + + return LayerTestResult(outputActual, + outputExpected, + outputHandle->GetShape(), + outputInfo.GetShape()); + } +} + +template +LayerTestResult ReverseV2SimpleTestEmptyAxis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is the same as input + auto descriptor = armnn::ReverseV2Descriptor(); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTestEmptyTensor( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. Empty tensor set so output is the same as input + auto descriptor = armnn::ReverseV2Descriptor(); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({0}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({0}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({}, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({}, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest1Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector {0}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, + 2, 1 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 2, 1, + 4, 3 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1, 0}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, + 2, 1 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest3Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 16, + 17, 18, 19, 20, + 21, 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 9, 10, 11, 12, + 5, 6, 7, 8, + 1, 2, 3, 4, + 21, 22, 23, 24, + 17, 18, 19, 20, + 13, 14, 15, 16 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector {0, 1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 16, + 17, 18, 19, 20, + 21, 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 21, 22, 23, 24, + 17, 18, 19, 20, + 13, 14, 15, 16, + 9, 10, 11, 12, + 5, 6, 7, 8, + 1, 2, 3, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest3Dim3Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1, 0, 2}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + 13, 14, 15, 16, + 17, 18, 19, 20, + 21, 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 24, 23, 22, 21, + 20, 19, 18, 17, + 16, 15, 14, 13, + 12, 11, 10, 9, + 8, 7, 6, 5, + 4, 3, 2, 1 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest4Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {0}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, 12, + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24, + 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, 12 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest4Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {0, 1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, 12, + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 19, 20, 21, + 22, 23, 24, + 13, 14, 15, + 16, 17, 18, + 7, 8, 9, + 10, 11, 12, + 1, 2, 3, + 4, 5, 6 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest4Dim3Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {0, 1, 2}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, 12, + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 22, 23, 24, + 19, 20, 21, + 16, 17, 18, + 13, 14, 15, + 10, 11, 12, + 7, 8, 9, + 4, 5, 6, + 1, 2, 3 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2SimpleTest4Dim4Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {0, 1, 2, 3}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, 12, + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 24, 23, 22, + 21, 20, 19, + 18, 17, 16, + 15, 14, 13, + 12, 11, 10, + 9, 8, 7, + 6, 5, 4, + 3, 2, 1 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2EvenRowOddColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 3}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 3}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 3, 2, 1, + 6, 5, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2EvenRowOddColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 3, 1}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 3, 1}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 3, 2, 1, + 6, 5, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2EvenRowEvenColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2EvenRowEvenColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2OddRowOddColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({3, 3}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({3, 3}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 3, 2, 1, + 6, 5, 4, + 9, 8, 7 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2OddRowOddColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({3, 3, 1}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({3, 3, 1}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 3, 2, 1, + 6, 5, 4, + 9, 8, 7 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2OddRowEvenColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({3, 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({3, 4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, 2, 1, + 8, 7, 6, 5, + 12, 11, 10, 9 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2OddRowEvenColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({3, 4, 1}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({3, 4, 1}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12 + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, 2, 1, + 8, 7, 6, 5, + 12, 11, 10, 9 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2NegAxisTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {-1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template +LayerTestResult ReverseV2NegAxisTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + // Simple test with default descriptor. No axes set so output is + // the same as input + auto descriptor = armnn::ReverseV2Descriptor(std::vector {1, -1}); + + float qScale = 1.0f; + int32_t qOffset = 0; + + armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset); + armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset); + + std::vector input = armnnUtils::QuantizedVector({ + 1, 2, 3, 4, + 5, 6, 7, 8, + }, qScale, qOffset); + + std::vector outputExpected = armnnUtils::QuantizedVector({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template LayerTestResult, 2> +ReverseV2SimpleTestEmptyAxis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTestEmptyTensor( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest1Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest3Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest3Dim3Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest4Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest4Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest4Dim3Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest4Dim4Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2EvenRowOddColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2EvenRowOddColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2EvenRowEvenColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2EvenRowEvenColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2OddRowOddColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2OddRowOddColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2OddRowEvenColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2OddRowEvenColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2NegAxisTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2NegAxisTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult, 2> +ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); \ No newline at end of file diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp new file mode 100644 index 0000000000..a40e7734a0 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.hpp @@ -0,0 +1,156 @@ +// +// Copyright © 2023 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include + +#include + +#include + +// Empty test cases + +template> +LayerTestResult ReverseV2SimpleTestEmptyAxis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTestEmptyTensor( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Multidimensional input tensor and multi-axis tests +// These test cases are conducted with even-row-even-column input tensors + +template> +LayerTestResult ReverseV2SimpleTest1Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest3Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest3Dim3Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest4Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest4Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest4Dim3Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2SimpleTest4Dim4Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Even and odd row number tests +// These tests are conducted with 1-axis input param + +template> +LayerTestResult ReverseV2EvenRowOddColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2EvenRowOddColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2EvenRowEvenColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2EvenRowEvenColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2OddRowOddColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2OddRowOddColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2OddRowEvenColTest2Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ReverseV2OddRowEvenColTest3Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// Negative axis input tests with even-row-even-column input + +// one negative axis +template> +LayerTestResult ReverseV2NegAxisTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +// one negative and one positive axis +template> +LayerTestResult ReverseV2NegAxisTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); \ No newline at end of file -- cgit v1.2.1