| // |
| // 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, |
| const std::vector<T>& input, |
| const std::vector<int>& axis, |
| const std::vector<T>& outputExpected, |
| const armnn::TensorInfo& inputInfo, |
| const armnn::TensorInfo& axisInfo, |
| 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> axisHandle = tensorHandleFactory.CreateTensorHandle(axisInfo); |
| std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo); |
| |
| armnn::ReverseV2QueueDescriptor queueDescriptor; |
| armnn::WorkloadInfo workloadInfo; |
| |
| AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get()); |
| AddInputToWorkload(queueDescriptor, workloadInfo, axisInfo, axisHandle.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, |
| axisInfo, |
| outputInfo, |
| reasonIfUnsupported); |
| if (!result.m_Supported) |
| { |
| return result; |
| } |
| |
| auto workload = workloadFactory.CreateWorkload(armnn::LayerType::ReverseV2, queueDescriptor, workloadInfo); |
| |
| inputHandle->Allocate(); |
| axisHandle->Allocate(); |
| outputHandle->Allocate(); |
| |
| if (input.data() != nullptr) |
| { |
| CopyDataToITensorHandle(inputHandle.get(), input.data()); |
| } |
| if (axis.data() != nullptr) |
| { |
| CopyDataToITensorHandle(axisHandle.get(), axis.data()); |
| } |
| |
| workload->PostAllocationConfigure(); |
| ExecuteWorkload(*workload, memoryManager); |
| |
| if (outputActual.data() != nullptr) |
| { |
| 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 no axes set so output is the same as input |
| |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({}, armnn::DataType::Signed32, 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<int> axis = armnnUtils::QuantizedVector<int>({1, 1}, qScale, qOffset); |
| |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ |
| 1, 2, |
| 3, 4 |
| }, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| 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 empty input tensor |
| |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({0}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({0}, armnn::DataType::Signed32, qScale, qOffset); |
| armnn::TensorInfo outputInfo({0}, ArmnnType, qScale, qOffset); |
| |
| std::vector<T> input = armnnUtils::QuantizedVector<T>({}, qScale, qOffset); |
| std::vector<int> axis = armnnUtils::QuantizedVector<int>({}, qScale, qOffset); |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({}, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest1Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset); |
| armnn::TensorInfo outputInfo({4}, ArmnnType, qScale, qOffset); |
| |
| std::vector<T> input = armnnUtils::QuantizedVector<T>({ |
| 1, 2, |
| 3, 4 |
| }, qScale, qOffset); |
| |
| std::vector<int> axis = {0}; |
| |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ |
| 4, 3, |
| 2, 1 |
| }, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest2Dim1Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ |
| 2, 1, |
| 4, 3 |
| }, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest2Dim2Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, 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<int> axis = {1,0}; |
| |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ |
| 4, 3, |
| 2, 1 |
| }, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest3Dim1Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest3Dim2Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, 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<int> axis = {0, 1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest3Dim3Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({3}, armnn::DataType::Signed32, 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<int> axis = {1, 0, 2}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest4Dim1Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {0}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest4Dim2Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, 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<int> axis = {0, 1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest4Dim3Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({3}, armnn::DataType::Signed32, 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<int> axis = {0, 1, 2}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2SimpleTest4Dim4Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({4}, armnn::DataType::Signed32, 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<int> axis = {0, 1, 2, 3}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2EvenRowOddColTest2Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 3}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ |
| 3, 2, 1, |
| 6, 5, 4 |
| }, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2EvenRowOddColTest3Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 3, 1}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({ |
| 3, 2, 1, |
| 6, 5, 4 |
| }, qScale, qOffset); |
| |
| return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory, |
| memoryManager, |
| tensorHandleFactory, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2EvenRowEvenColTest2Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2EvenRowEvenColTest3Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2OddRowOddColTest2Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({3, 3}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2OddRowOddColTest3Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({3, 3, 1}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2OddRowEvenColTest2Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({3, 4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2OddRowEvenColTest3Dim( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({3, 4, 1}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2NegAxisTest2Dim1Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, 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<int> axis = {-1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| outputInfo); |
| } |
| |
| template<armnn::DataType ArmnnType, typename T> |
| LayerTestResult<T, 2> ReverseV2NegAxisTest3Dim2Axis( |
| armnn::IWorkloadFactory& workloadFactory, |
| const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, |
| const armnn::ITensorHandleFactory& tensorHandleFactory) |
| { |
| float qScale = 1.0f; |
| int32_t qOffset = 0; |
| |
| armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset); |
| armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, 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<int> axis = {1, -1}; |
| |
| 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, |
| input, |
| axis, |
| outputExpected, |
| inputInfo, |
| axisInfo, |
| 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); |