18 #include <boost/multi_array.hpp> 22 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
32 const std::vector<T>& inputData,
33 const std::vector<T>& outputExpectedData,
34 unsigned int inputWidth,
35 unsigned int inputHeight,
36 unsigned int inputChannels,
37 unsigned int inputBatchSize)
40 unsigned int outputWidth = inputWidth;
41 unsigned int outputHeight = inputHeight;
42 unsigned int outputChannels = inputChannels;
43 unsigned int outputBatchSize = inputBatchSize;
45 armnn::TensorInfo inputTensorInfo({ inputBatchSize, inputChannels, inputHeight, inputWidth }, ArmnnType);
47 armnn::TensorInfo outputTensorInfo({ outputBatchSize, outputChannels, outputHeight, outputWidth }, ArmnnType);
49 if(armnn::IsQuantizedType<T>())
52 inputTensorInfo.SetQuantizationOffset(inputOffset);
54 outputTensorInfo.SetQuantizationScale(outputScale);
55 outputTensorInfo.SetQuantizationOffset(outputOffset);
60 auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
63 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
64 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
70 AddInputToWorkload(descriptor, workloadInfo, inputTensorInfo, inputHandle.get());
71 AddOutputToWorkload(descriptor, workloadInfo, outputTensorInfo, outputHandle.get());
74 descriptor.m_Parameters.m_A = upperBound;
75 descriptor.m_Parameters.m_B = lowerBound;
77 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateActivation(descriptor, workloadInfo);
79 inputHandle->Allocate();
80 outputHandle->Allocate();
88 result.
outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputExpectedData);
97 unsigned int inputWidth = 4u;
98 unsigned int inputHeight = 5u;
99 unsigned int inputChannels = 1u;
100 unsigned int inputBatchSize = 1;
102 std::vector<float> input = std::vector<float>{
103 -2.0f, 0.1f, 0.5f, 1.25f,
104 0.786f, 0.9875f, -1.5f, 0.384f,
105 1.0001f, 3.5f, 7.5f, 0.896f,
106 2.126f, 2.0f, 0.3f, 0.15f,
107 0.999f, 1.2f, 0.89f, 6.1f,
111 std::vector<float> output = std::vector<float>{
112 -1.0f, 0.1f, 0.5f, 1.0f,
113 0.786f, 0.9875f, -1.0f, 0.384f,
114 1.0f, 1.0f, 1.0f, 0.896f,
115 1.0f, 1.0f, 0.3f, 0.15f,
116 0.999f, 1.0f, 0.89f, 1.0f,
119 return BoundedReLuTestCommon<armnn::DataType::Float32>(
120 workloadFactory, memoryManager, 1.0f, -1.0f, 1.0f, 0, 1.0f, 0, input, output,
121 inputWidth, inputHeight, inputChannels, inputBatchSize);
128 unsigned int inputWidth = 4u;
129 unsigned int inputHeight = 5u;
130 unsigned int inputChannels = 1u;
131 unsigned int inputBatchSize = 1;
133 std::vector<float> input = std::vector<float>{
134 -1.0f, 0.1f, 0.5f, 6.25f,
135 0.786f, 5.9875f, -0.5f, 0.384f,
136 6.0001f, 3.5f, 7.5f, 0.896f,
137 2.126f, 12.0f, 0.3f, 0.15f,
138 0.999f, 1.2f, 0.89f, 6.1f,
142 std::vector<float> output = std::vector<float>{
143 0.0f, 0.1f, 0.5f, 6.0f,
144 0.786f, 5.9875f, 0.0f, 0.384f,
145 6.0f, 3.5f, 6.0f, 0.896f,
146 2.126f, 6.0f, 0.3f, 0.15f,
147 0.999f, 1.2f, 0.89f, 6.0f,
150 return BoundedReLuTestCommon<armnn::DataType::Float32>(
151 workloadFactory, memoryManager, 6.0f, 0.0f, 1.0f, 0, 1.0f, 0, input, output,
152 inputWidth, inputHeight, inputChannels, inputBatchSize);
159 unsigned int inputWidth = 3u;
160 unsigned int inputHeight = 2u;
161 unsigned int inputChannels = 1u;
162 unsigned int inputBatchSize = 1;
164 std::vector<uint8_t> input = std::vector<uint8_t>{
170 std::vector<uint8_t> output = std::vector<uint8_t>{
175 float inputScale = 12.0f / 255.0f;
176 int32_t inputOffset = 63;
177 float outputScale = 6.0f / 255.0f;
178 int32_t outputOffset = 0;
180 return BoundedReLuTestCommon<armnn::DataType::QAsymmU8>(
181 workloadFactory, memoryManager, 6.0f, 0.0f,
182 inputScale, inputOffset, outputScale, outputOffset,
183 input, output, inputWidth, inputHeight, inputChannels, inputBatchSize);
190 unsigned int inputWidth = 3u;
191 unsigned int inputHeight = 2u;
192 unsigned int inputChannels = 1u;
193 unsigned int inputBatchSize = 1;
195 std::vector<uint8_t> input = std::vector<uint8_t>{
201 std::vector<uint8_t> output = std::vector<uint8_t>{
206 int32_t inputOffset = 112;
207 float inputScale = 0.0125f;
209 return BoundedReLuTestCommon<armnn::DataType::QAsymmU8>(
210 workloadFactory, memoryManager, 1.0f, -1.0f,
211 inputScale, inputOffset, inputScale, inputOffset,
212 input, output, inputWidth, inputHeight, inputChannels, inputBatchSize);
218 struct BoundedReLuRandomInputTestTraits
220 constexpr
static unsigned int inputHeight = 31u;
221 constexpr
static unsigned int inputWidth = 19u;
222 constexpr
static unsigned int inputChannels = 4u;
223 constexpr
static unsigned int inputBatchSize = 2;
225 constexpr
static unsigned int outputHeight = inputHeight;
226 constexpr
static unsigned int outputWidth = inputWidth;
227 constexpr
static unsigned int outputChannels = inputChannels;
228 constexpr
static unsigned int outputBatchSize = inputBatchSize;
232 return armnn::TensorInfo({ inputBatchSize, inputChannels, inputHeight, inputWidth },
238 return armnn::TensorInfo({ outputBatchSize, outputChannels, outputHeight, outputWidth },
243 boost::multi_array<float, 4> BoundedReLuRandomInputTest(
252 const armnn::TensorInfo outputTensorInfo = BoundedReLuRandomInputTestTraits::GetOutputTensorInfo();
254 boost::multi_array<float, 4> output(GetTensorShapeAsArray<4>(outputTensorInfo));
258 auto input = MakeRandomTensor<float, 4>(inputTensorInfo, 4605828, lowerBound - 5.0f, upperBound * 2.0f);
261 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
262 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
268 AddInputToWorkload(descriptor, workloadInfo, inputTensorInfo, inputHandle.get());
269 AddOutputToWorkload(descriptor, workloadInfo, outputTensorInfo, outputHandle.get());
270 descriptor.m_Parameters = activationDescriptor;
272 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateActivation(descriptor, workloadInfo);
274 inputHandle->Allocate();
275 outputHandle->Allocate();
299 activationDescriptor.
m_A = upperBound;
300 activationDescriptor.
m_B = lowerBound;
302 result.
output = BoundedReLuRandomInputTest(
303 workloadFactory, memoryManager, 0.0f, upperBound, activationDescriptor);
305 refWorkloadFactory,
nullptr, 0.0f, upperBound, activationDescriptor);
310 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
318 unsigned int inputHeight = 20;
319 unsigned int inputWidth = 17;
320 unsigned int inputChannels = 3;
321 unsigned int batchSize = 5;
326 unsigned int shape[] = {batchSize, inputChannels, inputHeight, inputWidth};
332 if(armnn::IsQuantizedType<T>())
342 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
343 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
349 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
350 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
351 data.m_Parameters.m_A = 1.0f;
352 data.m_Parameters.m_B = 0.0f;
355 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateActivation(data, info);
357 inputHandle->Allocate();
358 outputHandle->Allocate();
360 boost::multi_array<T, 4> input = MakeRandomTensor<T, 4>(inputTensorInfo, 7123561);
377 return ConstantLinearActivationTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
384 return ConstantLinearActivationTestCommon<armnn::DataType::QAsymmU8>(
385 workloadFactory, memoryManager, 4.0f, 3);
392 return ConstantLinearActivationTestCommon<armnn::DataType::QSymmS16>(
393 workloadFactory, memoryManager, 0.1f, 0);
396 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
401 float activationParameterA,
402 float activationParameterB,
405 const std::vector<float>& inputData,
408 const std::vector<float>& outputExpectedData)
411 constexpr
static unsigned int inputWidth = 16u;
412 constexpr
static unsigned int inputHeight = 1u;
413 constexpr
static unsigned int inputChannels = 1u;
414 constexpr
static unsigned int inputBatchSize = 1u;
416 constexpr
static unsigned int outputWidth = inputWidth;
417 constexpr
static unsigned int outputHeight = inputHeight;
418 constexpr
static unsigned int outputChannels = inputChannels;
419 constexpr
static unsigned int outputBatchSize = inputBatchSize;
421 armnn::TensorInfo inputTensorInfo({ inputBatchSize, inputChannels, inputHeight, inputWidth }, ArmnnType);
422 armnn::TensorInfo outputTensorInfo({ outputBatchSize, outputChannels, outputHeight, outputWidth }, ArmnnType);
425 if(armnn::IsQuantizedType<T>())
428 inputTensorInfo.SetQuantizationOffset(offset);
429 outputTensorInfo.SetQuantizationScale(outScale);
430 outputTensorInfo.SetQuantizationOffset(outOffset);
435 auto input = MakeTensor<T, 4>(inputTensorInfo, armnnUtils::QuantizedVector<T>(inputData, scale, offset));
438 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
439 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
445 AddInputToWorkload(descriptor, workloadInfo, inputTensorInfo, inputHandle.get());
446 AddOutputToWorkload(descriptor, workloadInfo, outputTensorInfo, outputHandle.get());
448 descriptor.m_Parameters.m_Function = activationFunction;
449 descriptor.m_Parameters.m_A = activationParameterA;
450 descriptor.m_Parameters.m_B = activationParameterB;
452 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateActivation(descriptor, workloadInfo);
454 inputHandle->Allocate();
455 outputHandle->Allocate();
465 MakeTensor<T, 4>(outputTensorInfo, armnnUtils::QuantizedVector<T>(outputExpectedData, outScale, outOffset));
470 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
477 std::vector<float> inputData =
479 -0.1f, -0.2f, -0.3f, -0.4f,
480 0.1f, 0.2f, 0.3f, 0.4f,
481 -1.0f, -2.0f, -3.0f, -4.0f,
482 1.0f, 2.0f, 3.0f, 4.0f
486 auto f = [](
float value)
488 return 1.0f / (1.0f + std::exp(-value));
490 std::vector<float> outputExpectedData(inputData.size());
491 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
493 return SimpleActivationTest<ArmnnType>(workloadFactory,
510 return SimpleSigmoidTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
517 return SimpleSigmoidTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.1f, 50);
524 return SimpleSigmoidTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
527 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
534 std::vector<float> inputData = {
535 -0.1f, -0.2f, -0.3f, -0.4f,
536 0.1f, 0.2f, 0.3f, 0.4f,
537 -1.0f, -2.0f, -3.0f, -4.0f,
538 1.0f, 2.0f, 3.0f, 4.0f
542 auto f = [](
float value)
544 return std::fmax(0.0f, value);
546 std::vector<float> outputExpectedData(inputData.size());
547 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
549 return SimpleActivationTest<ArmnnType>(workloadFactory,
566 return ReLuTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
574 return ReLuTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.1f, 0);
581 return ReLuTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
585 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
592 std::vector<float> inputData = {
593 -0.1f, -0.2f, -0.3f, -0.4f,
594 0.1f, 0.2f, 0.3f, 0.4f,
595 -1.0f, -2.0f, -3.0f, -4.0f,
596 1.0f, 2.0f, 3.0f, 4.0f
598 const float a = 1.0f;
599 const float b = -1.0f;
601 auto f = [a, b](
float value)
603 return std::min(a, std::max(b, value));
605 std::vector<float> outputExpectedData(inputData.size());
606 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
608 return SimpleActivationTest<ArmnnType>(workloadFactory,
625 return ReLuTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
630 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
637 std::vector<float> inputData = {
638 -0.1f, -0.2f, -0.3f, -0.4f,
639 0.1f, 0.2f, 0.3f, 0.4f,
640 -1.0f, -2.0f, -3.0f, -4.0f,
641 1.0f, 2.0f, 3.0f, 4.0f
645 auto f = [](
float value)
647 return std::log(1.0f + std::exp(value));
649 std::vector<float> outputExpectedData(inputData.size());
650 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
652 return SimpleActivationTest<ArmnnType>(workloadFactory,
669 return SoftReLuTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
676 return SoftReLuTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.0625f, 64);
683 return SoftReLuTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
686 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
693 std::vector<float> inputData = {
694 -0.1f, -0.2f, -0.3f, -0.4f,
695 0.1f, 0.2f, 0.3f, 0.4f,
696 -1.0f, -2.0f, -3.0f, -4.0f,
697 1.0f, 2.0f, 3.0f, 4.0f
700 const float a = 0.01f;
702 auto f = [a](
float value)
704 return value > 0.0f ? value : (value * a);
706 std::vector<float> outputExpectedData(inputData.size());
707 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
709 return SimpleActivationTest<ArmnnType>(workloadFactory,
726 return LeakyReLuTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
733 return LeakyReLuTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.0625f, 64);
740 return LeakyReLuTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
743 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
750 std::vector<float> inputData = {
751 -0.1f, -0.2f, -0.3f, -0.4f,
752 0.1f, 0.2f, 0.3f, 0.4f,
753 -1.0f, -2.0f, -3.0f, -4.0f,
754 1.0f, 2.0f, 3.0f, 4.0f
758 auto f = [](
float value)
760 return std::abs(value);
762 std::vector<float> outputExpectedData(inputData.size());
763 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
765 return SimpleActivationTest<ArmnnType>(workloadFactory,
782 return AbsTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
789 return AbsTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.0625f, 64);
796 return AbsTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
804 const int inputDataSize = 120;
805 std::vector<float> inputData(inputDataSize);
807 for (
unsigned int i = 0u; i < inputDataSize; ++i)
809 inputData[i] =
static_cast<float>(i) / 10;
812 auto f = [](
float value)
814 return std::sqrt(value);
816 std::vector<float> outputExpectedData(inputDataSize);
817 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
826 auto input = MakeTensor<float, 5>(inputTensorInfo, inputData);
829 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
830 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
835 AddInputToWorkload(descriptor, workloadInfo, inputTensorInfo, inputHandle.get());
836 AddOutputToWorkload(descriptor, workloadInfo, outputTensorInfo, outputHandle.get());
840 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateActivation(descriptor, workloadInfo);
842 inputHandle->Allocate();
843 outputHandle->Allocate();
852 result.outputExpected = MakeTensor<float, 5>(outputTensorInfo, outputExpectedData);
857 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
864 std::vector<float> inputData = {
865 0.1f, 0.2f, 0.3f, 0.4f,
866 0.1f, 0.2f, 0.3f, 0.4f,
867 1.0f, 2.0f, 3.0f, 4.0f,
868 1.0f, 2.0f, 3.0f, 4.0f
872 auto f = [](
float value)
874 return std::sqrt(value);
876 std::vector<float> outputExpectedData(inputData.size());
877 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
879 return SimpleActivationTest<ArmnnType>(workloadFactory,
896 return SqrtTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
903 return SqrtTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.0625f, 64);
910 return SqrtTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
913 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
920 std::vector<float> inputData = {
921 -0.1f, -0.2f, -0.3f, -0.4f,
922 0.1f, 0.2f, 0.3f, 0.4f,
923 -1.0f, -2.0f, -3.0f, -4.0f,
924 1.0f, 2.0f, 3.0f, 4.0f
928 auto f = [](
float value)
930 return std::pow(value,2);
932 std::vector<float> outputExpectedData(inputData.size());
933 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
935 return SimpleActivationTest<ArmnnType>(workloadFactory,
952 return SquareTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
959 return SquareTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.0625f, 64);
966 return SquareTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
969 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
976 std::vector<float> inputData = {
977 -0.1f, -0.2f, -0.3f, -0.4f,
978 0.1f, 0.2f, 0.3f, 0.4f,
979 -1.0f, -2.0f, -3.0f, -4.0f,
980 1.0f, 2.0f, 3.0f, 4.0f
983 const float a = 2.0f;
984 const float b = 3.0f;
986 auto f = [a, b](
float value)
988 return a * tanhf(b * value);
990 std::vector<float> outputExpectedData(inputData.size());
991 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
993 return SimpleActivationTest<ArmnnType>(workloadFactory,
1003 outputExpectedData);
1010 return TanhTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
1017 return TanhTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.1f, 64);
1024 return TanhTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
1028 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
1035 std::vector<float> inputData = {
1036 -0.1f, -0.2f, -0.3f, -0.4f,
1037 0.1f, 0.2f, 0.3f, 0.4f,
1038 -1.0f, -2.0f, -3.0f, -4.0f,
1039 1.0f, 2.0f, 3.0f, 4.0f
1043 const float a = 0.01f;
1045 auto f = [a](
float value)
1047 return (value >= 0) ? value : a * (expf(value) - 1);
1049 std::vector<float> outputExpectedData(inputData.size());
1050 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
1052 return SimpleActivationTest<ArmnnType>(workloadFactory,
1062 outputExpectedData);
1069 return EluTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
1076 return EluTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.1f, 64);
1083 return EluTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
1087 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
1094 std::vector<float> inputData = {
1095 -0.1f, -0.2f, -0.3f, -0.4f,
1096 0.1f, 0.2f, 0.3f, 0.4f,
1097 -1.0f, -2.0f, -3.0f, -4.0f,
1098 1.0f, 2.0f, 3.0f, 4.0f
1101 auto f = [](
float x)
1106 float reLu6_step1 = std::max((x + 3),0.0f);
1107 float reLu6Complete = std::min(reLu6_step1, 6.0f);
1108 float hardSwish_step1 = x * reLu6Complete;
1109 float result = hardSwish_step1 / 6;
1112 std::vector<float> outputExpectedData(inputData.size());
1113 std::transform(inputData.begin(), inputData.end(), outputExpectedData.begin(), f);
1115 return SimpleActivationTest<ArmnnType>(workloadFactory,
1125 outputExpectedData);
1132 return HardSwishTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.1f, 0);
1139 return HardSwishTestCommon<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, 0.1f, 64);
1146 return HardSwishTestCommon<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, 0.1f, 0);
1150 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
1156 unsigned int batchSize = 5,
1157 float qScale = 0.0f,
1158 int32_t qOffset = 0)
1161 unsigned int width = 17;
1162 unsigned int height = 29;
1163 unsigned int channels = 2;
1171 unsigned int shape[] = {batchSize, channels, height, width};
1177 if(armnn::IsQuantizedType<T>())
1185 float minVal = -10.f;
1191 boost::multi_array<T, 4> input = MakeRandomTensor<T, 4>(inputTensorInfo, 21453, minVal, 10.f);
1195 auto boostArrayExtents = boost::extents
1197 [boost::numeric_cast<boost::multi_array_types::extent_gen::index>(channels)]
1199 [boost::numeric_cast<boost::multi_array_types::extent_gen::index>(width)];
1200 ret.output.resize(boostArrayExtents);
1201 ret.outputExpected.resize(boostArrayExtents);
1204 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.
CreateTensorHandle(inputTensorInfo);
1205 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.
CreateTensorHandle(outputTensorInfo);
1207 std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refWorkloadFactory.
CreateTensorHandle(inputTensorInfo);
1208 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refWorkloadFactory.
CreateTensorHandle(outputTensorInfo);
1213 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
1214 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
1215 data.m_Parameters.m_A = a;
1216 data.m_Parameters.m_B = b;
1217 data.m_Parameters.m_Function = f;
1221 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
1222 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
1224 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.
CreateActivation(data, info);
1226 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.
CreateActivation(refData, refInfo);
1229 inputHandle->Allocate();
1230 outputHandle->Allocate();
1231 inputHandleRef->Allocate();
1232 outputHandleRef->Allocate();
1237 workload->Execute();
1238 workloadRef->Execute();
1251 unsigned int batchSize)
1253 return CompareActivationTestImpl<armnn::DataType::Float32>(
1254 workloadFactory, memoryManager, refWorkloadFactory, f, batchSize);
1263 return CompareActivationTestImpl<armnn::DataType::QAsymmU8>(
1264 workloadFactory, memoryManager, refWorkloadFactory, f, 5, 0.1f, 50);
1273 return CompareActivationTestImpl<armnn::DataType::QSymmS16>(
1274 workloadFactory, memoryManager, refWorkloadFactory, f, 5, 0.1f, 0);
LayerTestResult< int16_t, 4 > SqrtInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > ReLuInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > SoftReLuTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< float, 4 > LeakyReLuTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > SquareTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< float, 4 > SquareTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > BoundedReLuInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > SoftReLuTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > ReLuTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
LayerTestResult< uint8_t, 4 > SquareUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > SqrtUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > SquareInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > CompareActivationTestImpl(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, armnn::ActivationFunction f, unsigned int batchSize=5, float qScale=0.0f, int32_t qOffset=0)
boost::multi_array< T, n > outputExpected
LayerTestResult< T, 4 > TanhTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< uint8_t, 4 > BoundedReLuUint8UpperAndLowerBoundTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > CompareBoundedReLuTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, float upperBound, float lowerBound)
LayerTestResult< T, 4 > SqrtTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
void IgnoreUnused(Ts &&...)
virtual std::unique_ptr< IWorkload > CreateActivation(const ActivationQueueDescriptor &descriptor, const WorkloadInfo &info) const
LayerTestResult< T, 4 > ReLuTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< T, 4 > LeakyReLuTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< float, 4 > EluTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > SimpleSigmoidInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > SoftReLuUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > HardSwishTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< float, 4 > BoundedReLuUpperAndLowerBoundTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > LeakyReLuInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > TanhInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > LeakyReLuUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > HardSwishInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > EluInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
#define ARMNN_NO_DEPRECATE_WARN_END
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
LayerTestResult< float, 4 > TanhTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > AbsUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > CompareActivationUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, armnn::ActivationFunction f)
LayerTestResult< T, 4 > SimpleActivationTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::ActivationFunction activationFunction, float activationParameterA, float activationParameterB, float scale, int32_t offset, const std::vector< float > &inputData, float outScale, int32_t outOffset, const std::vector< float > &outputExpectedData)
LayerTestResult< int16_t, 4 > SoftReLuInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > AbsTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void SetQuantizationScale(float scale)
#define ARMNN_ASSERT(COND)
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
LayerTestResult< float, 5 > SqrtNNTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
An ActivationDescriptor for the ActivationLayer.
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
min(a, max(b, input)) ReLu1 & ReLu6.
LayerTestResult< T, 4 > AbsTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const =0
boost::multi_array< T, n > output
LayerTestResult< int16_t, 4 > AbsInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
float m_A
Alpha upper bound value used by the activation functions. (BoundedReLu, Linear, TanH, Elu).
LayerTestResult< uint8_t, 4 > EluUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > ReLuUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > ConstantLinearActivationTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< uint8_t, 4 > ConstantLinearActivationUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > CompareActivationTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, armnn::ActivationFunction f, unsigned int batchSize)
LayerTestResult< T, 4 > EluTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
LayerTestResult< int16_t, 4 > ConstantLinearActivationInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > SimpleSigmoidTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
Contains information about inputs and outputs to a layer.
void SetQuantizationOffset(int32_t offset)
LayerTestResult< float, 4 > BoundedReLuUpperBoundOnlyTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > ConstantLinearActivationTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale=0.0f, int32_t qOffset=0)
LayerTestResult< uint8_t, 4 > BoundedReLuUint8UpperBoundOnlyTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< int16_t, 4 > CompareActivationInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, armnn::ActivationFunction f)
LayerTestResult< uint8_t, 4 > HardSwishUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< float, 4 > HardSwishTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > BoundedReLuTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float upperBound, float lowerBound, float inputScale, int32_t inputOffset, float outputScale, int32_t outputOffset, const std::vector< T > &inputData, const std::vector< T > &outputExpectedData, unsigned int inputWidth, unsigned int inputHeight, unsigned int inputChannels, unsigned int inputBatchSize)
LayerTestResult< uint8_t, 4 > TanhUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
LayerTestResult< T, 4 > SimpleSigmoidTestCommon(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, float qScale, int32_t qOffset)
float m_B
Beta lower bound value used by the activation functions. (BoundedReLu, Linear, TanH).
TensorInfo GetInputTensorInfo(const Network *network)
LayerTestResult< float, 4 > SqrtTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
ActivationFunction m_Function
The activation function to use (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).
LayerTestResult< uint8_t, 4 > SimpleSigmoidUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager)
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)