diff options
author | Matthew Sloyan <matthew.sloyan@arm.com> | 2020-11-13 09:47:35 +0000 |
---|---|---|
committer | Francis Murtagh <francis.murtagh@arm.com> | 2020-11-17 12:50:19 +0000 |
commit | 91c4171421633b3ff9764bd586f43137aef0ff1a (patch) | |
tree | 5462dfa28832b6da848a3acb5ba471f0813ec52b /delegate/src/test/ControlTest.cpp | |
parent | 145c88f851d12d2cadc2f080d232c1d5963d6e47 (diff) | |
download | armnn-91c4171421633b3ff9764bd586f43137aef0ff1a.tar.gz |
IVGCVSW-5486 TfLiteDelegate: Implement Concat and Mean operators
* Implemented Concatenation & Mean operator.
* Added unit tests for Concatenation & Mean operator.
* Added CompareOutputData function to TestUtils.hpp.
Signed-off-by: Matthew Sloyan <matthew.sloyan@arm.com>
Change-Id: I31b7b1517a9ce041c3269f69f16a419f967d0fb0
Diffstat (limited to 'delegate/src/test/ControlTest.cpp')
-rw-r--r-- | delegate/src/test/ControlTest.cpp | 420 |
1 files changed, 420 insertions, 0 deletions
diff --git a/delegate/src/test/ControlTest.cpp b/delegate/src/test/ControlTest.cpp new file mode 100644 index 0000000000..43491be982 --- /dev/null +++ b/delegate/src/test/ControlTest.cpp @@ -0,0 +1,420 @@ +// +// Copyright © 2020 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ControlTestHelper.hpp" + +#include <armnn_delegate.hpp> + +#include <flatbuffers/flatbuffers.h> +#include <tensorflow/lite/schema/schema_generated.h> + +#include <doctest/doctest.h> + +namespace armnnDelegate +{ + +// CONCATENATION Operator +void ConcatUint8TwoInputsTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> inputShape { 2, 2 }; + std::vector<int32_t> expectedOutputShape { 4, 2 }; + + // Set input and output data + std::vector<std::vector<uint8_t>> inputValues; + std::vector<uint8_t> inputValue1 { 0, 1, 2, 3 }; // Lower bounds + std::vector<uint8_t> inputValue2 { 252, 253, 254, 255 }; // Upper bounds + inputValues.push_back(inputValue1); + inputValues.push_back(inputValue2); + + std::vector<uint8_t> expectedOutputValues { 0, 1, 2, 3, 252, 253, 254, 255 }; + + ConcatenationTest<uint8_t>(tflite::BuiltinOperator_CONCATENATION, + ::tflite::TensorType_UINT8, + backends, + inputShape, + expectedOutputShape, + inputValues, + expectedOutputValues); +} + +void ConcatInt16TwoInputsTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> inputShape { 2, 2 }; + std::vector<int32_t> expectedOutputShape { 4, 2 }; + + std::vector<std::vector<int16_t>> inputValues; + std::vector<int16_t> inputValue1 { -32768, -16384, -1, 0 }; + std::vector<int16_t> inputValue2 { 1, 2, 16384, 32767 }; + inputValues.push_back(inputValue1); + inputValues.push_back(inputValue2); + + std::vector<int16_t> expectedOutputValues { -32768, -16384, -1, 0, 1, 2, 16384, 32767}; + + ConcatenationTest<int16_t>(tflite::BuiltinOperator_CONCATENATION, + ::tflite::TensorType_INT16, + backends, + inputShape, + expectedOutputShape, + inputValues, + expectedOutputValues); +} + +void ConcatFloat32TwoInputsTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> inputShape { 2, 2 }; + std::vector<int32_t> expectedOutputShape { 4, 2 }; + + std::vector<std::vector<float>> inputValues; + std::vector<float> inputValue1 { -127.f, -126.f, -1.f, 0.f }; + std::vector<float> inputValue2 { 1.f, 2.f, 126.f, 127.f }; + inputValues.push_back(inputValue1); + inputValues.push_back(inputValue2); + + std::vector<float> expectedOutputValues { -127.f, -126.f, -1.f, 0.f, 1.f, 2.f, 126.f, 127.f }; + + ConcatenationTest<float>(tflite::BuiltinOperator_CONCATENATION, + ::tflite::TensorType_FLOAT32, + backends, + inputShape, + expectedOutputShape, + inputValues, + expectedOutputValues); +} + +void ConcatThreeInputsTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> inputShape { 2, 2 }; + std::vector<int32_t> expectedOutputShape { 6, 2 }; + + std::vector<std::vector<uint8_t>> inputValues; + std::vector<uint8_t> inputValue1 { 0, 1, 2, 3 }; + std::vector<uint8_t> inputValue2 { 125, 126, 127, 128 }; + std::vector<uint8_t> inputValue3 { 252, 253, 254, 255 }; + inputValues.push_back(inputValue1); + inputValues.push_back(inputValue2); + inputValues.push_back(inputValue3); + + std::vector<uint8_t> expectedOutputValues { 0, 1, 2, 3, 125, 126, 127, 128, 252, 253, 254, 255 }; + + ConcatenationTest<uint8_t>(tflite::BuiltinOperator_CONCATENATION, + ::tflite::TensorType_UINT8, + backends, + inputShape, + expectedOutputShape, + inputValues, + expectedOutputValues); +} + +void ConcatAxisTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> inputShape { 1, 2, 2 }; + std::vector<int32_t> expectedOutputShape { 1, 2, 4 }; + + std::vector<std::vector<uint8_t>> inputValues; + std::vector<uint8_t> inputValue1 { 0, 1, 2, 3 }; + std::vector<uint8_t> inputValue3 { 252, 253, 254, 255 }; + inputValues.push_back(inputValue1); + inputValues.push_back(inputValue3); + + std::vector<uint8_t> expectedOutputValues { 0, 1, 252, 253, 2, 3, 254, 255 }; + + ConcatenationTest<uint8_t>(tflite::BuiltinOperator_CONCATENATION, + ::tflite::TensorType_UINT8, + backends, + inputShape, + expectedOutputShape, + inputValues, + expectedOutputValues, + 2); +} + +// MEAN Operator +void MeanUint8KeepDimsTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> input0Shape { 1, 3 }; + std::vector<int32_t> input1Shape { 1 }; + std::vector<int32_t> expectedOutputShape { 1, 1 }; + + std::vector<uint8_t> input0Values { 5, 10, 15 }; // Inputs + std::vector<int32_t> input1Values { 1 }; // Axis + + std::vector<uint8_t> expectedOutputValues { 10 }; + + MeanTest<uint8_t>(tflite::BuiltinOperator_MEAN, + ::tflite::TensorType_UINT8, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues, + true); +} + +void MeanUint8Test(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> input0Shape { 1, 2, 2 }; + std::vector<int32_t> input1Shape { 1 }; + std::vector<int32_t> expectedOutputShape { 2, 2 }; + + std::vector<uint8_t> input0Values { 5, 10, 15, 20 }; // Inputs + std::vector<int32_t> input1Values { 0 }; // Axis + + std::vector<uint8_t> expectedOutputValues { 5, 10, 15, 20 }; + + MeanTest<uint8_t>(tflite::BuiltinOperator_MEAN, + ::tflite::TensorType_UINT8, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues, + false); +} + +void MeanFp32KeepDimsTest(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> input0Shape { 1, 2, 2 }; + std::vector<int32_t> input1Shape { 1 }; + std::vector<int32_t> expectedOutputShape { 1, 1, 2 }; + + std::vector<float> input0Values { 1.0f, 1.5f, 2.0f, 2.5f }; // Inputs + std::vector<int32_t> input1Values { 1 }; // Axis + + std::vector<float> expectedOutputValues { 1.5f, 2.0f }; + + MeanTest<float>(tflite::BuiltinOperator_MEAN, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues, + true); +} + +void MeanFp32Test(std::vector<armnn::BackendId>& backends) +{ + std::vector<int32_t> input0Shape { 1, 2, 2, 1 }; + std::vector<int32_t> input1Shape { 1 }; + std::vector<int32_t> expectedOutputShape { 1, 2, 1 }; + + std::vector<float> input0Values { 1.0f, 1.5f, 2.0f, 2.5f }; // Inputs + std::vector<int32_t> input1Values { 2 }; // Axis + + std::vector<float> expectedOutputValues { 1.25f, 2.25f }; + + MeanTest<float>(tflite::BuiltinOperator_MEAN, + ::tflite::TensorType_FLOAT32, + backends, + input0Shape, + input1Shape, + expectedOutputShape, + input0Values, + input1Values, + expectedOutputValues, + false); +} + +// CONCATENATION Tests. +TEST_SUITE("Concatenation_CpuAccTests") +{ + +TEST_CASE ("Concatenation_Uint8_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + ConcatUint8TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Int16_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + ConcatInt16TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Float32_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + ConcatFloat32TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Three_Inputs_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + ConcatThreeInputsTest(backends); +} + +TEST_CASE ("Concatenation_Axis_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + ConcatAxisTest(backends); +} + +} + +TEST_SUITE("Concatenation_GpuAccTests") +{ + +TEST_CASE ("Concatenation_Uint8_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + ConcatUint8TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Int16_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + ConcatInt16TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Float32_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + ConcatFloat32TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Three_Inputs_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + ConcatThreeInputsTest(backends); +} + +TEST_CASE ("Concatenation_Axis_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + ConcatAxisTest(backends); +} + +} + +TEST_SUITE("Concatenation_CpuRefTests") +{ + +TEST_CASE ("Concatenation_Uint8_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + ConcatUint8TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Int16_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + ConcatInt16TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Float32_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + ConcatFloat32TwoInputsTest(backends); +} + +TEST_CASE ("Concatenation_Three_Inputs_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + ConcatThreeInputsTest(backends); +} + +TEST_CASE ("Concatenation_Axis_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + ConcatAxisTest(backends); +} + +} + +// MEAN Tests +TEST_SUITE("Mean_CpuAccTests") +{ + +TEST_CASE ("Mean_Uint8_KeepDims_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + MeanUint8KeepDimsTest(backends); +} + +TEST_CASE ("Mean_Uint8_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + MeanUint8Test(backends); +} + +TEST_CASE ("Mean_Fp32_KeepDims_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + MeanFp32KeepDimsTest(backends); +} + +TEST_CASE ("Mean_Fp32_CpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc}; + MeanFp32Test(backends); +} + +} + +TEST_SUITE("Mean_GpuAccTests") +{ + +TEST_CASE ("Mean_Uint8_KeepDims_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + MeanUint8KeepDimsTest(backends); +} + +TEST_CASE ("Mean_Uint8_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + MeanUint8Test(backends); +} + +TEST_CASE ("Mean_Fp32_KeepDims_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + MeanFp32KeepDimsTest(backends); +} + +TEST_CASE ("Mean_Fp32_GpuAcc_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc}; + MeanFp32Test(backends); +} + +} + +TEST_SUITE("Mean_CpuRefTests") +{ + +TEST_CASE ("Mean_Uint8_KeepDims_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + MeanUint8KeepDimsTest(backends); +} + +TEST_CASE ("Mean_Uint8_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + MeanUint8Test(backends); +} + +TEST_CASE ("Mean_Fp32_KeepDims_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + MeanFp32KeepDimsTest(backends); +} + +TEST_CASE ("Mean_Fp32_CpuRef_Test") +{ + std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef}; + MeanFp32Test(backends); +} + +} + +} // namespace armnnDelegate
\ No newline at end of file |