From c001e14fb6267acefd6325719d9b5cb997eebe5b Mon Sep 17 00:00:00 2001 From: Jan Eilers Date: Thu, 19 Nov 2020 17:50:34 +0000 Subject: IVGCVSW-5548 Fix delegate ElementwiseUnary tests for CpuAcc/GpuAcc * Apply new test suite structure to be able to filter for backends For ElementwiseBinary and ElementwiseUnary * Add tolerance to data comparison Signed-off-by: Jan Eilers Change-Id: Iccabb68f316c93533e1076da5822ebc199e23739 --- delegate/src/test/Convolution2dTest.cpp | 6 +- delegate/src/test/ElementwiseBinaryTest.cpp | 405 ++++++++++++++--------- delegate/src/test/ElementwiseUnaryTest.cpp | 234 +++++++++---- delegate/src/test/ElementwiseUnaryTestHelper.hpp | 14 +- 4 files changed, 425 insertions(+), 234 deletions(-) diff --git a/delegate/src/test/Convolution2dTest.cpp b/delegate/src/test/Convolution2dTest.cpp index 4e9377a24d..f8ee7b1efd 100644 --- a/delegate/src/test/Convolution2dTest.cpp +++ b/delegate/src/test/Convolution2dTest.cpp @@ -220,7 +220,7 @@ void Conv2DWithBiasesRelu6Uint8Test(std::vector& backends) biasValues); } -TEST_SUITE("Convolution2dTest_CpuRef") +TEST_SUITE("Convolution2dTest_CpuRefTests") { TEST_CASE ("Conv2DWithBiases_Fp32_CpuRef_Test") @@ -249,7 +249,7 @@ TEST_CASE ("Conv2DWithBiases_Relu6_Uint8_CpuRef_Test") } //End of TEST_SUITE("Convolution2dTest_CpuRef") -TEST_SUITE("Convolution2dTest_CpuAcc") +TEST_SUITE("Convolution2dTest_CpuAccTests") { TEST_CASE ("Conv2DWithBiases_Fp32_CpuAcc_Test") @@ -278,7 +278,7 @@ Conv2DWithBiasesRelu6Uint8Test(backends); } //End of TEST_SUITE("Convolution2dTest_CpuAcc") -TEST_SUITE("Convolution2dTest_GpuAcc") +TEST_SUITE("Convolution2dTest_GpuAccTests") { TEST_CASE ("Conv2DWithBiases_Fp32_GpuAcc_Test") diff --git a/delegate/src/test/ElementwiseBinaryTest.cpp b/delegate/src/test/ElementwiseBinaryTest.cpp index 2a8c91b2ef..0ae60a296d 100644 --- a/delegate/src/test/ElementwiseBinaryTest.cpp +++ b/delegate/src/test/ElementwiseBinaryTest.cpp @@ -657,289 +657,382 @@ void SubUint8Test(std::vector& backends) expectedOutputValues, 1.0f, 0); } -TEST_SUITE("ElementwiseBinaryTest") +TEST_SUITE("ElementwiseBinary_GpuAccTests") { TEST_CASE ("ADD_FP32_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::GpuAcc }; AddFP32Test(backends); } -TEST_CASE ("ADD_FP32_CpuAcc_Test") +TEST_CASE ("ADD_Broadcast_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - AddFP32Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + AddBroadcastTest(backends); } -TEST_CASE ("ADD_Broadcast_GpuAcc_Test") +TEST_CASE ("ADD_Activation_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - AddBroadcastTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + AddActivationTest(backends); } -TEST_CASE ("ADD_Broadcast_CpuAcc_Test") +TEST_CASE ("ADD_UINT8_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - AddBroadcastTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + AddUint8Test(backends); } -TEST_CASE ("ADD_Activation_GpuAcc_Test") +TEST_CASE ("DIV_FP32_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - AddActivationTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + DivFP32Test(backends); } -TEST_CASE ("ADD_Actiation_CpuAcc_Test") +TEST_CASE ("DIV_Broadcast_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - AddActivationTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + DivBroadcastTest(backends); } -TEST_CASE ("ADD_UINT8_GpuAcc_Test") +TEST_CASE ("DIV_UINT8_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - AddUint8Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + DivUint8Test(backends); } -TEST_CASE ("ADD_UINT8_CpuAcc_Test") +TEST_CASE ("MAX_FP32_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - AddUint8Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MaxFP32Test(backends); } -TEST_CASE ("DIV_FP32_GpuAcc_Test") +TEST_CASE ("MAX_Broadcast_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - DivFP32Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MaxBroadcastTest(backends); } -TEST_CASE ("DIV_FP32_CpuAcc_Test") +TEST_CASE ("MAX_UINT8_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - DivFP32Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MaxUint8Test(backends); } -TEST_CASE ("DIV_Broadcast_GpuAcc_Test") +TEST_CASE ("MIN_FP32_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - DivBroadcastTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MinFP32Test(backends); } -TEST_CASE ("DIV_Broadcast_CpuAcc_Test") +TEST_CASE ("MIN_Broadcast_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - DivBroadcastTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MinBroadcastTest(backends); } -TEST_CASE ("DIV_UINT8_GpuAcc_Test") +TEST_CASE ("MIN_UINT8_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - DivUint8Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MinUint8Test(backends); } -TEST_CASE ("DIV_UINT8_CpuAcc_Test") +TEST_CASE ("MUL_FP32_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - DivUint8Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MulFP32Test(backends); } -TEST_CASE ("MAX_FP32_GpuAcc_Test") +TEST_CASE ("MUL_Broadcast_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MaxFP32Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MulBroadcastTest(backends); } -TEST_CASE ("MAX_FP32_CpuAcc_Test") +TEST_CASE ("MUL_Activation_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MaxFP32Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MulActivationTest(backends); } -TEST_CASE ("MAX_Broadcast_GpuAcc_Test") +TEST_CASE ("MUL_UINT8_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MaxBroadcastTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + MulUint8Test(backends); } -TEST_CASE ("MAX_Broadcast_CpuAcc_Test") +TEST_CASE ("SUB_FP32_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MaxBroadcastTest(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + SubFP32Test(backends); } -TEST_CASE ("MAX_UINT8_GpuAcc_Test") +TEST_CASE ("SUB_Broadcast_GpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MaxUint8Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + SubBroadcastTest(backends); } -TEST_CASE ("MAX_UINT8_CpuAcc_Test") +TEST_CASE ("SUB_UINT8_GpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MaxUint8Test(backends); + std::vector backends = { armnn::Compute::GpuAcc }; + SubUint8Test(backends); } -TEST_CASE ("MIN_FP32_GpuAcc_Test") +} //TEST_SUITE("ElementwiseBinary_GpuAccTests") + + + +TEST_SUITE("ElementwiseBinary_CpuAccTests") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MinFP32Test(backends); + +TEST_CASE ("ADD_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + AddFP32Test(backends); } -TEST_CASE ("MIN_FP32_CpuAcc_Test") +TEST_CASE ("ADD_Broadcast_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MinFP32Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + AddBroadcastTest(backends); } -TEST_CASE ("MIN_Broadcast_GpuAcc_Test") +TEST_CASE ("ADD_Actiation_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MinBroadcastTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + AddActivationTest(backends); } -TEST_CASE ("MIN_Broadcast_CpuAcc_Test") +TEST_CASE ("ADD_UINT8_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MinBroadcastTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + AddUint8Test(backends); } -TEST_CASE ("MIN_UINT8_GpuAcc_Test") +TEST_CASE ("DIV_FP32_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MinUint8Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + DivFP32Test(backends); } -TEST_CASE ("MIN_UINT8_CpuAcc_Test") +TEST_CASE ("DIV_Broadcast_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MinUint8Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + DivBroadcastTest(backends); } -TEST_CASE ("MUL_FP32_GpuAcc_Test") +TEST_CASE ("DIV_UINT8_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MulFP32Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + DivUint8Test(backends); } -TEST_CASE ("MUL_FP32_CpuAcc_Test") +TEST_CASE ("MAX_FP32_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MulFP32Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MaxFP32Test(backends); } -TEST_CASE ("MUL_Broadcast_GpuAcc_Test") +TEST_CASE ("MAX_Broadcast_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MulBroadcastTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MaxBroadcastTest(backends); } -TEST_CASE ("MUL_Broadcast_CpuAcc_Test") +TEST_CASE ("MAX_UINT8_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MulBroadcastTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MaxUint8Test(backends); } -TEST_CASE ("MUL_Activation_GpuAcc_Test") +TEST_CASE ("MIN_FP32_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MulActivationTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MinFP32Test(backends); } -TEST_CASE ("MUL_Actiation_CpuAcc_Test") +TEST_CASE ("MIN_Broadcast_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MulActivationTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MinBroadcastTest(backends); } -TEST_CASE ("MUL_UINT8_GpuAcc_Test") +TEST_CASE ("MIN_UINT8_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - MulUint8Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MinUint8Test(backends); } -TEST_CASE ("MUL_UINT8_CpuAcc_Test") +TEST_CASE ("MUL_FP32_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - MulUint8Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MulFP32Test(backends); } -TEST_CASE ("SUB_FP32_GpuAcc_Test") +TEST_CASE ("MUL_Broadcast_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - SubFP32Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MulBroadcastTest(backends); } -TEST_CASE ("SUB_FP32_CpuAcc_Test") +TEST_CASE ("MUL_Actiation_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; - SubFP32Test(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MulActivationTest(backends); } -TEST_CASE ("SUB_Broadcast_GpuAcc_Test") +TEST_CASE ("MUL_UINT8_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; - SubBroadcastTest(backends); + std::vector backends = { armnn::Compute::CpuAcc }; + MulUint8Test(backends); +} + +TEST_CASE ("SUB_FP32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + SubFP32Test(backends); } TEST_CASE ("SUB_Broadcast_CpuAcc_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuAcc }; SubBroadcastTest(backends); } -TEST_CASE ("SUB_UINT8_GpuAcc_Test") +TEST_CASE ("SUB_UINT8_CpuAcc_Test") { - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuAcc }; SubUint8Test(backends); } -TEST_CASE ("SUB_UINT8_CpuAcc_Test") +} // TEST_SUITE("ElementwiseBinary_CpuAccTests") + + +TEST_SUITE("ElementwiseBinary_CpuRefTests") +{ + +TEST_CASE ("ADD_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + AddFP32Test(backends); +} + +TEST_CASE ("ADD_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + AddBroadcastTest(backends); +} + +TEST_CASE ("ADD_Actiation_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + AddActivationTest(backends); +} + +TEST_CASE ("ADD_UINT8_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + AddUint8Test(backends); +} + +TEST_CASE ("DIV_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + DivFP32Test(backends); +} + +TEST_CASE ("DIV_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + DivBroadcastTest(backends); +} + +TEST_CASE ("DIV_UINT8_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + DivUint8Test(backends); +} + +TEST_CASE ("MAX_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MaxFP32Test(backends); +} + +TEST_CASE ("MAX_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MaxBroadcastTest(backends); +} + +TEST_CASE ("MAX_UINT8_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MaxUint8Test(backends); +} + +TEST_CASE ("MIN_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MinFP32Test(backends); +} + +TEST_CASE ("MIN_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MinBroadcastTest(backends); +} + +TEST_CASE ("MIN_UINT8_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MinUint8Test(backends); +} + +TEST_CASE ("MUL_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MulFP32Test(backends); +} + +TEST_CASE ("MUL_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MulBroadcastTest(backends); +} + +TEST_CASE ("MUL_Actiation_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MulActivationTest(backends); +} + +TEST_CASE ("MUL_UINT8_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + MulUint8Test(backends); +} + +TEST_CASE ("SUB_FP32_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + SubFP32Test(backends); +} + +TEST_CASE ("SUB_Broadcast_CpuRef_Test") +{ + std::vector backends = { armnn::Compute::CpuRef }; + SubBroadcastTest(backends); +} + +TEST_CASE ("SUB_UINT8_CpuRef_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuRef }; SubUint8Test(backends); } -} // End of TEST_SUITE("ElementwiseBinaryTest") +} // TEST_SUITE("ElementwiseBinary_CpuRefTests") } // namespace armnnDelegate \ No newline at end of file diff --git a/delegate/src/test/ElementwiseUnaryTest.cpp b/delegate/src/test/ElementwiseUnaryTest.cpp index c504707c99..012ffde057 100644 --- a/delegate/src/test/ElementwiseUnaryTest.cpp +++ b/delegate/src/test/ElementwiseUnaryTest.cpp @@ -19,14 +19,13 @@ namespace armnnDelegate { -TEST_SUITE("ElementwiseUnaryTest") +TEST_SUITE("ElementwiseUnary_GpuAccTests") { TEST_CASE ("Abs_Float32_GpuAcc_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::GpuAcc }; // Set input data std::vector inputValues { @@ -42,55 +41,119 @@ TEST_CASE ("Abs_Float32_GpuAcc_Test") ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Abs_Float32_CpuAcc_Test") +TEST_CASE ("Exp_Float32_GpuAcc_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::GpuAcc }; // Set input data std::vector inputValues { - -0.1f, -0.2f, -0.3f, - 0.1f, 0.2f, 0.3f + 5.0f, 4.0f, + 3.0f, 2.0f, + 1.0f, 1.1f + }; + // Set output data + std::vector expectedOutputValues + { + 148.413159102577f, 54.598150033144f, + 20.085536923188f, 7.389056098931f, + 2.718281828459f, 3.004166023946f + }; + + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues); +} + +TEST_CASE ("Neg_Float32_GpuAcc_Test") +{ + // Create the ArmNN Delegate + std::vector backends = { armnn::Compute::GpuAcc }; + // Set input data + std::vector inputValues + { + 1.f, 0.f, 3.f, + 25.f, 64.f, 100.f + }; + // Set output data + std::vector expectedOutputValues + { + -1.f, 0.f, -3.f, + -25.f, -64.f, -100.f + }; + + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues); +} + +TEST_CASE ("Rsqrt_Float32_GpuAcc_Test") +{ + // Create the ArmNN Delegate + std::vector backends = { armnn::Compute::GpuAcc }; + // Set input data + std::vector inputValues + { + 1.f, 4.f, 16.f, + 25.f, 64.f, 100.f + }; + // Set output data + std::vector expectedOutputValues + { + 1.f, 0.5f, 0.25f, + 0.2f, 0.125f, 0.1f + }; + + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues); +} + +TEST_CASE ("Sqrt_Float32_GpuAcc_Test") +{ + // Create the ArmNN Delegate + std::vector backends = { armnn::Compute::GpuAcc }; + // Set input data + std::vector inputValues + { + 9.0f, 4.25f, 81.9f, + 0.1f, 0.9f, 169.0f }; // Calculate output data std::vector expectedOutputValues(inputValues.size()); for (unsigned int i = 0; i < inputValues.size(); ++i) { - expectedOutputValues[i] = std::abs(inputValues[i]); + expectedOutputValues[i] = std::sqrt(inputValues[i]); } - ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues); + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Exp_Float32_GpuAcc_Test") +} // TEST_SUITE("ElementwiseUnary_GpuAccTests") + + + +TEST_SUITE("ElementwiseUnary_CpuAccTests") +{ + +TEST_CASE ("Abs_Float32_CpuAcc_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuAcc }; // Set input data std::vector inputValues { - 5.0f, 4.0f, - 3.0f, 2.0f, - 1.0f, 1.1f + -0.1f, -0.2f, -0.3f, + 0.1f, 0.2f, 0.3f }; - // Set output data - std::vector expectedOutputValues + // Calculate output data + std::vector expectedOutputValues(inputValues.size()); + for (unsigned int i = 0; i < inputValues.size(); ++i) { - 148.413159102577f, 54.598150033144f, - 20.085536923188f, 7.389056098931f, - 2.718281828459f, 3.004166023946f - }; + expectedOutputValues[i] = std::abs(inputValues[i]); + } - ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues); + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues); } TEST_CASE ("Exp_Float32_CpuAcc_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuAcc }; // Set input data std::vector inputValues { @@ -109,11 +172,10 @@ TEST_CASE ("Exp_Float32_CpuAcc_Test") ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Neg_Float32_GpuAcc_Test") +TEST_CASE ("Neg_Float32_CpuAcc_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuAcc }; // Set input data std::vector inputValues { @@ -130,94 +192,136 @@ TEST_CASE ("Neg_Float32_GpuAcc_Test") ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Neg_Float32_CpuAcc_Test") +TEST_CASE ("Rsqrt_Float32_CpuAcc_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuAcc }; // Set input data std::vector inputValues { - 1.f, 0.f, 3.f, + 1.f, 4.f, 16.f, 25.f, 64.f, 100.f }; // Set output data std::vector expectedOutputValues { - -1.f, 0.f, -3.f, - -25.f, -64.f, -100.f + 1.f, 0.5f, 0.25f, + 0.2f, 0.125f, 0.1f }; - ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues); + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Rsqrt_Float32_GpuAcc_Test") +TEST_CASE ("Sqrt_Float32_CpuAcc_Test") +{ + std::vector backends = { armnn::Compute::CpuAcc }; + // Set input data + std::vector inputValues + { + 9.0f, 4.25f, 81.9f, + 0.1f, 0.9f, 169.0f + }; + // Calculate output data + std::vector expectedOutputValues(inputValues.size()); + for (unsigned int i = 0; i < inputValues.size(); ++i) + { + expectedOutputValues[i] = std::sqrt(inputValues[i]); + } + + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues); +} + +} // TEST_SUITE("ElementwiseUnary_CpuAccTests") + + +TEST_SUITE("ElementwiseUnary_CpuRefTests") +{ + +TEST_CASE ("Abs_Float32_CpuRef_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuRef }; // Set input data std::vector inputValues { - 1.f, 4.f, 16.f, - 25.f, 64.f, 100.f + -0.1f, -0.2f, -0.3f, + 0.1f, 0.2f, 0.3f + }; + // Calculate output data + std::vector expectedOutputValues(inputValues.size()); + for (unsigned int i = 0; i < inputValues.size(); ++i) + { + expectedOutputValues[i] = std::abs(inputValues[i]); + } + + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_ABS, backends, inputValues, expectedOutputValues); +} + +TEST_CASE ("Exp_Float32_CpuRef_Test") +{ + // Create the ArmNN Delegate + std::vector backends = { armnn::Compute::CpuRef }; + // Set input data + std::vector inputValues + { + 5.0f, 4.0f, + 3.0f, 2.0f, + 1.0f, 1.1f }; // Set output data std::vector expectedOutputValues { - 1.f, 0.5f, 0.25f, - 0.2f, 0.125f, 0.1f + 148.413159102577f, 54.598150033144f, + 20.085536923188f, 7.389056098931f, + 2.718281828459f, 3.004166023946f }; - ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues); + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_EXP, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Rsqrt_Float32_CpuAcc_Test") +TEST_CASE ("Neg_Float32_CpuRef_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuRef }; // Set input data std::vector inputValues { - 1.f, 4.f, 16.f, + 1.f, 0.f, 3.f, 25.f, 64.f, 100.f }; // Set output data std::vector expectedOutputValues { - 1.f, 0.5f, 0.25f, - 0.2f, 0.125f, 0.1f + -1.f, 0.f, -3.f, + -25.f, -64.f, -100.f }; - ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues); + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_NEG, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Sqrt_Float32_GpuAcc_Test") +TEST_CASE ("Rsqrt_Float32_CpuRef_Test") { // Create the ArmNN Delegate - std::vector backends = { armnn::Compute::GpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuRef }; // Set input data std::vector inputValues { - 9.0f, 4.25f, 81.9f, - 0.1f, 0.9f, 169.0f + 1.f, 4.f, 16.f, + 25.f, 64.f, 100.f }; - // Calculate output data - std::vector expectedOutputValues(inputValues.size()); - for (unsigned int i = 0; i < inputValues.size(); ++i) + // Set output data + std::vector expectedOutputValues { - expectedOutputValues[i] = std::sqrt(inputValues[i]); - } + 1.f, 0.5f, 0.25f, + 0.2f, 0.125f, 0.1f + }; - ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues); + ElementwiseUnaryFP32Test(tflite::BuiltinOperator_RSQRT, backends, inputValues, expectedOutputValues); } -TEST_CASE ("Sqrt_Float32_CpuAcc_Test") +TEST_CASE ("Sqrt_Float32_CpuRef_Test") { - std::vector backends = { armnn::Compute::CpuAcc, - armnn::Compute::CpuRef }; + std::vector backends = { armnn::Compute::CpuRef }; // Set input data std::vector inputValues { @@ -234,6 +338,6 @@ TEST_CASE ("Sqrt_Float32_CpuAcc_Test") ElementwiseUnaryFP32Test(tflite::BuiltinOperator_SQRT, backends, inputValues, expectedOutputValues); } -} +} // TEST_SUITE("ElementwiseUnary_CpuRefTests") } // namespace armnnDelegate \ No newline at end of file diff --git a/delegate/src/test/ElementwiseUnaryTestHelper.hpp b/delegate/src/test/ElementwiseUnaryTestHelper.hpp index b4a55cbe99..348c8abcef 100644 --- a/delegate/src/test/ElementwiseUnaryTestHelper.hpp +++ b/delegate/src/test/ElementwiseUnaryTestHelper.hpp @@ -5,6 +5,8 @@ #pragma once +#include "TestUtils.hpp" + #include #include @@ -79,7 +81,7 @@ void ElementwiseUnaryFP32Test(tflite::BuiltinOperator unaryOperatorCode, std::vector& expectedOutputValues) { using namespace tflite; - const std::vector inputShape { { 3, 1, 2} }; + std::vector inputShape { { 3, 1, 2} }; std::vector modelBuffer = CreateElementwiseUnaryTfLiteModel(unaryOperatorCode, ::tflite::TensorType_FLOAT32, inputShape); @@ -126,15 +128,7 @@ void ElementwiseUnaryFP32Test(tflite::BuiltinOperator unaryOperatorCode, CHECK(armnnDelegateInterpreter->Invoke() == kTfLiteOk); // Compare output data - auto tfLiteDelegateOutputId = tfLiteInterpreter->outputs()[0]; - auto tfLiteDelageOutputData = tfLiteInterpreter->typed_tensor(tfLiteDelegateOutputId); - auto armnnDelegateOutputId = armnnDelegateInterpreter->outputs()[0]; - auto armnnDelegateOutputData = armnnDelegateInterpreter->typed_tensor(armnnDelegateOutputId); - for (size_t i = 0; i < inputValues.size(); i++) - { - CHECK(expectedOutputValues[i] == armnnDelegateOutputData[i]); - CHECK(tfLiteDelageOutputData[i] == armnnDelegateOutputData[i]); - } + armnnDelegate::CompareOutputData(tfLiteInterpreter, armnnDelegateInterpreter, inputShape, expectedOutputValues); } } // anonymous namespace -- cgit v1.2.1