diff options
Diffstat (limited to 'src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp')
| -rw-r--r-- | src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp | 1084 |
1 files changed, 1084 insertions, 0 deletions
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 <armnn/backends/IBackendInternal.hpp> +#include <armnn/backends/Workload.hpp> +#include <armnn/backends/WorkloadData.hpp> +#include <armnn/backends/WorkloadFactory.hpp> + +#include <armnnTestUtils/WorkloadTestUtils.hpp> +#include <armnnUtils/QuantizeHelper.hpp> +#include <armnnTestUtils/TensorCopyUtils.hpp> +#include <armnn/Optional.hpp> +#include <armnn/BackendHelper.hpp> + +namespace +{ + template<armnn::DataType ArmnnType, typename T, std::size_t NumDims> + LayerTestResult<T, NumDims> ReverseV2TestImpl( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory, + armnn::ReverseV2Descriptor descriptor, + const std::vector<T>& input, + const std::vector<T>& outputExpected, + const armnn::TensorInfo& inputInfo, + const armnn::TensorInfo& outputInfo) + { + LayerTestResult<T, NumDims> result(outputInfo); + std::vector<T> outputActual(outputInfo.GetNumElements()); + + std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo); + std::unique_ptr<armnn::ITensorHandle> 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<T, NumDims>(outputActual, + outputExpected, + outputHandle->GetShape(), + outputInfo.GetShape()); + } +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<T> input = armnnUtils::QuantizedVector<T>({}, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({}, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> ReverseV2SimpleTest1Dim( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, + 2, 1 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> ReverseV2SimpleTest2Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 2, 1, + 4, 3 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> ReverseV2SimpleTest2Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, + 3, 4 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, + 2, 1 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> ReverseV2SimpleTest3Dim1Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> ReverseV2SimpleTest3Dim2Axis( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 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<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 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<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, + 4, 5, 6 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 3, 2, 1, + 6, 5, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, + 4, 5, 6 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 3, 2, 1, + 6, 5, 4 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, 4, + 5, 6, 7, 8 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, 4, + 5, 6, 7, 8 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 3, 2, 1, + 6, 5, 4, + 9, 8, 7 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, + 4, 5, 6, + 7, 8, 9 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 3, 2, 1, + 6, 5, 4, + 9, 8, 7 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, 2, 1, + 8, 7, 6, 5, + 12, 11, 10, 9 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12 + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, 2, 1, + 8, 7, 6, 5, + 12, 11, 10, 9 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {-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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, 4, + 5, 6, 7, 8, + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template<armnn::DataType ArmnnType, typename T> +LayerTestResult<T, 2> 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<int> {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<T> input = armnnUtils::QuantizedVector<T>({ + 1, 2, 3, 4, + 5, 6, 7, 8, + }, qScale, qOffset); + + std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ + 4, 3, 2, 1, + 8, 7, 6, 5 + }, qScale, qOffset); + + return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, + memoryManager, + tensorHandleFactory, + descriptor, + input, + outputExpected, + inputInfo, + outputInfo); +} + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTestEmptyAxis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTestEmptyTensor<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest1Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest2Dim1Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest2Dim2Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest3Dim1Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest3Dim2Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest3Dim3Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest4Dim1Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest4Dim2Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest4Dim3Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2SimpleTest4Dim4Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2EvenRowOddColTest2Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2EvenRowOddColTest3Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2EvenRowEvenColTest2Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2EvenRowEvenColTest3Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2OddRowOddColTest2Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2OddRowOddColTest3Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2OddRowEvenColTest2Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2OddRowEvenColTest3Dim<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2NegAxisTest2Dim1Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 2> +ReverseV2NegAxisTest3Dim2Axis<armnn::DataType::Float32>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 2> +ReverseV2SimpleTest2Dim2Axis<armnn::DataType::Float16>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmS8>, 2> +ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QAsymmS8>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::QAsymmU8>, 2> +ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QAsymmU8>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult<armnn::ResolveType<armnn::DataType::QSymmS16>, 2> +ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QSymmS16>( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file |