Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / dcaa6109c95034aa3b945acd50a2882e40f13370 / . / src / backends / backendsCommon / test / LayerTests.hpp
blob: df33aa192e9981a440e92398ebd51000c373ca12 [file] [log] [blame]
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]1//
2// Copyright © 2017 Arm Ltd. All rights reserved.
David Beckecb56cd2018-09-05 12:52:57 +0100[diff] [blame]3// SPDX-License-Identifier: MIT
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]4//
5#pragma once
6
Aron Virginas-Tarc9cc8042018-11-01 16:15:57 +0000[diff] [blame]7#include <armnn/ArmNN.hpp>
8#include <armnn/Tensor.hpp>
9
10#include <Half.hpp>
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]11#include "TensorCopyUtils.hpp"
12#include "WorkloadTestUtils.hpp"
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]13#include "TensorUtils.hpp"
14#include "Permute.hpp"
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]15
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]16#include <backendsCommon/CpuTensorHandle.hpp>
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]17#include <backendsCommon/IBackendInternal.hpp>
18#include <backendsCommon/IMemoryManager.hpp>
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]19#include <reference/workloads/Decoders.hpp>
20#include <reference/workloads/Encoders.hpp>
21#include <test/TensorHelpers.hpp>
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]22
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]23#include <boost/multi_array.hpp>
24#include <boost/assert.hpp>
Aron Virginas-Tarc9cc8042018-11-01 16:15:57 +0000[diff] [blame]25
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]26#include <array>
27
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]28// Layer callables.
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]29
30namespace armnn
31{
32class IWorkloadFactory;
33}
34
35template <std::size_t n>
36boost::array<unsigned int, n> GetTensorShapeAsArray(const armnn::TensorInfo& tensorInfo)
37{
38 BOOST_ASSERT_MSG(n == tensorInfo.GetNumDimensions(),
39 "Attempting to construct a shape array of mismatching size");
40
41 boost::array<unsigned int, n> shape;
42 for (unsigned int i = 0; i < n; i++)
43 {
44 shape[i] = tensorInfo.GetShape()[i];
45 }
46 return shape;
47}
48
49template <typename T, std::size_t n>
50struct LayerTestResult
51{
52 LayerTestResult(const armnn::TensorInfo& outputInfo)
53 {
54 auto shape( GetTensorShapeAsArray<n>(outputInfo) );
55 output.resize(shape);
56 outputExpected.resize(shape);
57 supported = true;
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]58 compareBoolean = false;
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]59 }
60
61 boost::multi_array<T, n> output;
62 boost::multi_array<T, n> outputExpected;
63 bool supported;
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]64 bool compareBoolean;
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]65};
66
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]67LayerTestResult<float, 4> SimpleConvolution2d3x5Test(
68 armnn::IWorkloadFactory& workloadFactory,
69 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
70 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]71 const armnn::DataLayout layout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]72
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]73LayerTestResult<float, 4> SimpleConvolution2d3x3Test(
74 armnn::IWorkloadFactory& workloadFactory,
75 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
76 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]77 const armnn::DataLayout layout);
Francis Murtaghd59116e2018-10-04 16:03:07 +0100[diff] [blame]78
Mike Kelly7332ed82018-12-20 17:03:06 +0000[diff] [blame]79LayerTestResult<float, 4> SimpleConvolution2d3x3Stride2x2Test(
80 armnn::IWorkloadFactory& workloadFactory,
81 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
82 bool biasEnabled,
83 const armnn::DataLayout layout);
84
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]85LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(
86 armnn::IWorkloadFactory& workloadFactory,
87 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
88 bool biasEnabled);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]89
Teresa Charlinedeeb162019-06-14 11:09:19 +0100[diff] [blame]90LayerTestResult<float, 4> Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]91 armnn::IWorkloadFactory& workloadFactory,
92 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Teresa Charlinedeeb162019-06-14 11:09:19 +0100[diff] [blame]93 armnn::DataLayout layout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]94
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]95LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(
96 armnn::IWorkloadFactory& workloadFactory,
97 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Teresa Charlinedeeb162019-06-14 11:09:19 +0100[diff] [blame]98 armnn::DataLayout layout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]99
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]100LayerTestResult<float, 4> Convolution1dTest(
101 armnn::IWorkloadFactory& workloadFactory,
102 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
103 bool biasEnabled);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]104
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]105LayerTestResult<uint8_t, 4> Convolution1dUint8Test(
106 armnn::IWorkloadFactory& workloadFactory,
107 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
108 bool biasEnabled);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]109
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]110LayerTestResult<float, 4> DepthwiseConvolution2dTest(
111 armnn::IWorkloadFactory& workloadFactory,
112 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
113 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]114 const armnn::DataLayout layout);
Nikhil Rajcec6b652018-10-12 13:51:57 +0100[diff] [blame]115
Teresa Charlinedeeb162019-06-14 11:09:19 +0100[diff] [blame]116template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
117LayerTestResult<T, 4> Convolution2d3x3Dilation3x3Test(
118 armnn::IWorkloadFactory& workloadFactory,
119 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
120 bool biasEnabled,
121 const armnn::DataLayout layout);
122
123template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
124LayerTestResult<T, 4> Convolution2d2x3x3Dilation3x3Test(
125 armnn::IWorkloadFactory& workloadFactory,
126 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
127 bool biasEnabled,
128 const armnn::DataLayout layout);
129
Teresa Charlin20b1f882019-06-19 09:34:37 +0100[diff] [blame]130template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
Teresa Charlin2b7519d2019-07-09 15:45:35 +0100[diff] [blame]131LayerTestResult<T, 4> Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test(
132 armnn::IWorkloadFactory &workloadFactory,
133 const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager,
134 bool biasEnabled,
135 const armnn::DataLayout layout);
136
137template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
Teresa Charlin20b1f882019-06-19 09:34:37 +0100[diff] [blame]138LayerTestResult<T, 4> DepthwiseConvolution2d3x3Dilation3x3Test(
139 armnn::IWorkloadFactory& workloadFactory,
140 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
141 bool biasEnabled,
142 const armnn::DataLayout layout);
143
144template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
145LayerTestResult<T, 4> DepthwiseConvolution2d2x3x3Dilation3x3Test(
146 armnn::IWorkloadFactory& workloadFactory,
147 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
148 bool biasEnabled,
149 const armnn::DataLayout layout);
150
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]151LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(
152 armnn::IWorkloadFactory& workloadFactory,
153 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
154 bool biasEnabled);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]155
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]156LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(
157 armnn::IWorkloadFactory& workloadFactory,
158 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
159 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]160 const armnn::DataLayout layout);
surmeh013537c2c2018-05-18 16:31:43 +0100[diff] [blame]161
Matthew Jacksond6a9dee2019-07-22 13:53:24 +0100[diff] [blame]162LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul64Test(
163 armnn::IWorkloadFactory& workloadFactory,
164 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
165
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]166LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(
167 armnn::IWorkloadFactory& workloadFactory,
168 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
169 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]170 const armnn::DataLayout layout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]171
Teresa Charlin20b1f882019-06-19 09:34:37 +0100[diff] [blame]172LayerTestResult<float, 4> SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTest(
173 armnn::IWorkloadFactory& workloadFactory,
174 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Bruno Goncalves22972f02019-04-26 21:03:24 -0300[diff] [blame]175
Nattapat Chaimanowong649dd952019-01-22 16:10:44 +0000[diff] [blame]176LayerTestResult<float, 4> CompareDepthwiseConvolution2dFloatTest(
177 armnn::IWorkloadFactory& workloadFactory,
178 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
179 armnn::IWorkloadFactory& refWorkloadFactory,
180 const armnn::DataLayout layout);
181
182LayerTestResult<uint8_t, 4> CompareDepthwiseConvolution2dUint8Test(
183 armnn::IWorkloadFactory& workloadFactory,
184 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
185 armnn::IWorkloadFactory& refWorkloadFactory,
186 const armnn::DataLayout layout);
187
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]188LayerTestResult<float, 4> SimpleMaxPooling2dSize2x2Stride2x2Test(
189 armnn::IWorkloadFactory& workloadFactory,
190 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
191 bool forceNoPadding);
James Conroy45a9b772018-10-31 11:47:53 +0000[diff] [blame]192
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]193LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(
194 armnn::IWorkloadFactory& workloadFactory,
195 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
196 bool forceNoPadding);
James Conroy45a9b772018-10-31 11:47:53 +0000[diff] [blame]197
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]198LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Int16Test(
199 armnn::IWorkloadFactory& workloadFactory,
200 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
201 bool forceNoPadding);
202
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]203LayerTestResult<float, 4> SimpleMaxPooling2dSize3x3Stride2x4Test(
204 armnn::IWorkloadFactory& workloadFactory,
205 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
206 bool forceNoPadding);
207
208LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(
209 armnn::IWorkloadFactory& workloadFactory,
210 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
211 bool forceNoPadding );
212
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]213LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Int16Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]214 armnn::IWorkloadFactory& workloadFactory,
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]215 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
216 bool forceNoPadding );
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]217
218LayerTestResult<float, 4> SimpleMaxPooling2dTest(
219 armnn::IWorkloadFactory& workloadFactory,
220 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]221 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]222
223LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(
224 armnn::IWorkloadFactory& workloadFactory,
225 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]226 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]227
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]228LayerTestResult<int16_t, 4> SimpleMaxPooling2dInt16Test(
229 armnn::IWorkloadFactory& workloadFactory,
230 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
231 const armnn::DataLayout dataLayout);
232
233LayerTestResult<float, 4> IgnorePaddingSimpleMaxPooling2dTest(
234 armnn::IWorkloadFactory& workloadFactory,
235 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
236
237LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(
238 armnn::IWorkloadFactory& workloadFactory,
239 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
240
241LayerTestResult<int16_t, 4> IgnorePaddingSimpleMaxPooling2dInt16Test(
242 armnn::IWorkloadFactory& workloadFactory,
243 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
244
245LayerTestResult<float, 4> IgnorePaddingMaxPooling2dSize3Test(
246 armnn::IWorkloadFactory& workloadFactory,
247 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
248
249LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(
250 armnn::IWorkloadFactory& workloadFactory,
251 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
252
253LayerTestResult<int16_t, 4> IgnorePaddingMaxPooling2dSize3Int16Test(
254 armnn::IWorkloadFactory& workloadFactory,
255 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
256
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]257LayerTestResult<float, 4> SimpleAveragePooling2dTest(
258 armnn::IWorkloadFactory& workloadFactory,
259 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]260 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]261
262LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(
263 armnn::IWorkloadFactory& workloadFactory,
264 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]265 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]266
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]267LayerTestResult<int16_t, 4> SimpleAveragePooling2dInt16Test(
268 armnn::IWorkloadFactory& workloadFactory,
269 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
270 const armnn::DataLayout dataLayout);
271
272LayerTestResult<float, 4> LargeTensorsAveragePooling2dTest(
273 armnn::IWorkloadFactory& workloadFactory,
274 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
275
276LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(
277 armnn::IWorkloadFactory& workloadFactory,
278 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
279
280LayerTestResult<int16_t, 4> LargeTensorsAveragePooling2dInt16Test(
281 armnn::IWorkloadFactory& workloadFactory,
282 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
283
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]284LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(
285 armnn::IWorkloadFactory& workloadFactory,
286 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
287 bool forceNoPadding);
288
289LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dTest(
290 armnn::IWorkloadFactory& workloadFactory,
291 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
292
293LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(
294 armnn::IWorkloadFactory& workloadFactory,
295 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
296
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]297LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dInt16Test(
298 armnn::IWorkloadFactory& workloadFactory,
299 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
300
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]301LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTest(
302 armnn::IWorkloadFactory& workloadFactory,
303 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
304
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]305LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]306 armnn::IWorkloadFactory& workloadFactory,
307 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]308
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]309LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test(
310 armnn::IWorkloadFactory& workloadFactory,
311 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
312
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]313LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3Test(
314 armnn::IWorkloadFactory& workloadFactory,
315 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]316
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]317LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(
318 armnn::IWorkloadFactory& workloadFactory,
319 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]320
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]321LayerTestResult<int16_t, 4> IgnorePaddingAveragePooling2dSize3Int16Test(
322 armnn::IWorkloadFactory& workloadFactory,
323 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
324
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]325LayerTestResult<float, 4> SimpleL2Pooling2dTest(
326 armnn::IWorkloadFactory& workloadFactory,
327 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]328 const armnn::DataLayout dataLayout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]329
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]330LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(
331 armnn::IWorkloadFactory& workloadFactory,
332 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]333 const armnn::DataLayout dataLayout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]334
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]335LayerTestResult<int16_t, 4> SimpleL2Pooling2dInt16Test(
336 armnn::IWorkloadFactory& workloadFactory,
337 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
338 const armnn::DataLayout dataLayout);
339
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]340LayerTestResult<float, 4> L2Pooling2dSize3Stride1Test(
341 armnn::IWorkloadFactory& workloadFactory,
342 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]343
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]344LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(
345 armnn::IWorkloadFactory& workloadFactory,
346 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]347
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]348LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride1Int16Test(
349 armnn::IWorkloadFactory& workloadFactory,
350 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
351
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]352LayerTestResult<float, 4> L2Pooling2dSize3Stride3Test(
353 armnn::IWorkloadFactory& workloadFactory,
354 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]355
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]356LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(
357 armnn::IWorkloadFactory& workloadFactory,
358 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]359
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]360LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride3Int16Test(
361 armnn::IWorkloadFactory& workloadFactory,
362 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
363
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]364LayerTestResult<float, 4> L2Pooling2dSize3Stride4Test(
365 armnn::IWorkloadFactory& workloadFactory,
366 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]367
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]368LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(
369 armnn::IWorkloadFactory& workloadFactory,
370 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]371
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]372LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride4Int16Test(
373 armnn::IWorkloadFactory& workloadFactory,
374 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
375
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]376LayerTestResult<float, 4> L2Pooling2dSize7Test(
377 armnn::IWorkloadFactory& workloadFactory,
378 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]379
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]380LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(
381 armnn::IWorkloadFactory& workloadFactory,
382 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]383
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]384LayerTestResult<int16_t, 4> L2Pooling2dSize7Int16Test(
385 armnn::IWorkloadFactory& workloadFactory,
386 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
387
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]388LayerTestResult<float, 4> L2Pooling2dSize9Test(
389 armnn::IWorkloadFactory& workloadFactory,
390 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]391
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]392LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(
393 armnn::IWorkloadFactory& workloadFactory,
394 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
395
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]396LayerTestResult<int16_t, 4> L2Pooling2dSize9Int16Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]397 armnn::IWorkloadFactory& workloadFactory,
398 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
399
400LayerTestResult<float, 4> IgnorePaddingSimpleL2Pooling2dTest(
401 armnn::IWorkloadFactory& workloadFactory,
402 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
403
404LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(
405 armnn::IWorkloadFactory& workloadFactory,
406 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
407
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]408LayerTestResult<int16_t, 4> IgnorePaddingSimpleL2Pooling2dInt16Test(
409 armnn::IWorkloadFactory& workloadFactory,
410 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
411
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]412LayerTestResult<float, 4> IgnorePaddingL2Pooling2dSize3Test(
413 armnn::IWorkloadFactory& workloadFactory,
414 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
415
416LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(
417 armnn::IWorkloadFactory& workloadFactory,
418 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
419
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]420LayerTestResult<int16_t, 4> IgnorePaddingL2Pooling2dSize3Int16Test(
421 armnn::IWorkloadFactory& workloadFactory,
422 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
423
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]424LayerTestResult<float, 4> AsymmetricNonSquarePooling2dTest(
425 armnn::IWorkloadFactory& workloadFactory,
426 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
427
428LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(
429 armnn::IWorkloadFactory& workloadFactory,
430 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
431
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]432LayerTestResult<int16_t, 4> AsymmetricNonSquarePooling2dInt16Test(
433 armnn::IWorkloadFactory& workloadFactory,
434 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
435
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]436LayerTestResult<float, 4> ComparePooling2dTest(
437 armnn::IWorkloadFactory& workloadFactory,
438 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
439 armnn::IWorkloadFactory& refWorkloadFactory,
440 armnn::PoolingAlgorithm poolingType);
441
442LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(
443 armnn::IWorkloadFactory& workloadFactory,
444 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
445 armnn::IWorkloadFactory& refWorkloadFactory,
446 armnn::PoolingAlgorithm poolingType);
447
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]448LayerTestResult<int16_t, 4> ComparePooling2dInt16Test(
449 armnn::IWorkloadFactory& workloadFactory,
450 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
451 armnn::IWorkloadFactory& refWorkloadFactory,
452 armnn::PoolingAlgorithm poolingType);
453
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]454LayerTestResult<float, 4> ConstantLinearActivationTest(
455 armnn::IWorkloadFactory& workloadFactory,
456 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
457
458LayerTestResult<float, 4> SimpleNormalizationAcrossTest(
459 armnn::IWorkloadFactory& workloadFactory,
460 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
461
462LayerTestResult<float, 4> SimpleNormalizationWithinTest(
463 armnn::IWorkloadFactory& workloadFactory,
464 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
465
466LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(
467 armnn::IWorkloadFactory& workloadFactory,
468 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
469
470LayerTestResult<float, 2> SimpleSoftmaxTest(
471 armnn::IWorkloadFactory& workloadFactory,
472 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
473 float beta);
474
Francis Murtagh07f21212019-07-23 09:50:50 +0100[diff] [blame]475LayerTestResult<float, 2> SimpleAxisSoftmaxTest(
476 armnn::IWorkloadFactory& workloadFactory,
477 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
478 float beta,
479 int axis);
480
Narumol Prangnawarat65d30962019-03-14 11:55:03 +0000[diff] [blame]481LayerTestResult<float, 3> Simple3dSoftmaxTest(
482 armnn::IWorkloadFactory& workloadFactory,
483 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
484 float beta);
485
Francis Murtagh07f21212019-07-23 09:50:50 +0100[diff] [blame]486LayerTestResult<float, 3> Simple3dAxisSoftmaxTest(
487 armnn::IWorkloadFactory& workloadFactory,
488 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
489 float beta,
490 int axis);
491
Narumol Prangnawarat65d30962019-03-14 11:55:03 +0000[diff] [blame]492LayerTestResult<float, 4> Simple4dSoftmaxTest(
493 armnn::IWorkloadFactory& workloadFactory,
494 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
495 float beta);
496
Francis Murtagh07f21212019-07-23 09:50:50 +0100[diff] [blame]497LayerTestResult<float, 4> Simple4dAxisSoftmaxTest(
498 armnn::IWorkloadFactory& workloadFactory,
499 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
500 float beta,
501 int axis);
502
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]503LayerTestResult<uint8_t, 2> SimpleSoftmaxUint8Test(
504 armnn::IWorkloadFactory& workloadFactory,
505 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
506 float beta);
507
Narumol Prangnawarat65d30962019-03-14 11:55:03 +0000[diff] [blame]508LayerTestResult<uint8_t,3> Simple3dSoftmaxUint8Test(
509 armnn::IWorkloadFactory& workloadFactory,
510 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
511 float beta);
512
513LayerTestResult<uint8_t,4> Simple4dSoftmaxUint8Test(
514 armnn::IWorkloadFactory& workloadFactory,
515 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
516 float beta);
517
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]518LayerTestResult<int16_t,2> SimpleSoftmaxUint16Test(
519 armnn::IWorkloadFactory& workloadFactory,
520 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
521 float beta);
522
523LayerTestResult<int16_t,3> Simple3dSoftmaxUint16Test(
524 armnn::IWorkloadFactory& workloadFactory,
525 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
526 float beta);
527
528LayerTestResult<int16_t,4> Simple4dSoftmaxUint16Test(
529 armnn::IWorkloadFactory& workloadFactory,
530 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
531 float beta);
532
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]533LayerTestResult<float, 4> SimpleSigmoidTest(
534 armnn::IWorkloadFactory& workloadFactory,
535 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
536
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]537template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
538LayerTestResult<T, 4> SimpleReshapeTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]539 armnn::IWorkloadFactory& workloadFactory,
540 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
541
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]542template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
543LayerTestResult<T, 5> Reshape5dTest(
544 armnn::IWorkloadFactory& workloadFactory,
545 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
546
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]547LayerTestResult<float, 4> SimpleFloorTest(
548 armnn::IWorkloadFactory& workloadFactory,
549 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
550
551LayerTestResult<float, 1> Concatenation1dTest(
552 armnn::IWorkloadFactory& workloadFactory,
553 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
554
555LayerTestResult<float, 2> Concatenation2dDim0Test(
556 armnn::IWorkloadFactory& workloadFactory,
557 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
558
559LayerTestResult<float, 2> Concatenation2dDim1Test(
560 armnn::IWorkloadFactory& workloadFactory,
561 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
562
563LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(
564 armnn::IWorkloadFactory& workloadFactory,
565 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
566
567LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(
568 armnn::IWorkloadFactory& workloadFactory,
569 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
570
571LayerTestResult<float, 3> Concatenation3dDim0Test(
572 armnn::IWorkloadFactory& workloadFactory,
573 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
574
575LayerTestResult<float, 3> Concatenation3dDim1Test(
576 armnn::IWorkloadFactory& workloadFactory,
577 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
578
579LayerTestResult<float, 3> Concatenation3dDim2Test(
580 armnn::IWorkloadFactory& workloadFactory,
narpra015cdda352018-11-19 15:30:27 +0000[diff] [blame]581 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
582 bool useSubtensor);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]583
584LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(
585 armnn::IWorkloadFactory& workloadFactory,
586 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
587
588LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(
589 armnn::IWorkloadFactory& workloadFactory,
590 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
591
592LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(
593 armnn::IWorkloadFactory& workloadFactory,
narpra015cdda352018-11-19 15:30:27 +0000[diff] [blame]594 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
595 bool useSubtensor);
596
597LayerTestResult<float, 4> Concatenation4dDim0Test(
598 armnn::IWorkloadFactory& workloadFactory,
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]599 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
600
narpra015cdda352018-11-19 15:30:27 +0000[diff] [blame]601LayerTestResult<float, 4> Concatenation4dDim1Test(
602 armnn::IWorkloadFactory& workloadFactory,
603 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
604
605LayerTestResult<float, 4> Concatenation4dDim2Test(
606 armnn::IWorkloadFactory& workloadFactory,
607 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
608
609LayerTestResult<float, 4> Concatenation4dDim3Test(
610 armnn::IWorkloadFactory& workloadFactory,
611 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
612 bool useSubtensor);
613
614LayerTestResult<float, 4> Concatenation4dDiffShapeDim0Test(
615 armnn::IWorkloadFactory& workloadFactory,
616 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
617
618LayerTestResult<float, 4> Concatenation4dDiffShapeDim1Test(
619 armnn::IWorkloadFactory& workloadFactory,
620 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
621
622LayerTestResult<float, 4> Concatenation4dDiffShapeDim2Test(
623 armnn::IWorkloadFactory& workloadFactory,
624 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
625
626LayerTestResult<float, 4> Concatenation4dDiffShapeDim3Test(
627 armnn::IWorkloadFactory& workloadFactory,
628 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
629 bool useSubtensor);
630
631LayerTestResult<uint8_t, 4> Concatenation4dDim0Uint8Test(
632 armnn::IWorkloadFactory& workloadFactory,
633 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
634
635LayerTestResult<uint8_t, 4> Concatenation4dDim1Uint8Test(
636 armnn::IWorkloadFactory& workloadFactory,
637 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
638
639LayerTestResult<uint8_t, 4> Concatenation4dDim2Uint8Test(
640 armnn::IWorkloadFactory& workloadFactory,
641 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
642
643LayerTestResult<uint8_t, 4> Concatenation4dDim3Uint8Test(
644 armnn::IWorkloadFactory& workloadFactory,
645 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
646 bool useSubtensor);
647
648LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim0Uint8Test(
649 armnn::IWorkloadFactory& workloadFactory,
650 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
651
652LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim1Uint8Test(
653 armnn::IWorkloadFactory& workloadFactory,
654 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
655
656LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim2Uint8Test(
657 armnn::IWorkloadFactory& workloadFactory,
658 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
659
660LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim3Uint8Test(
661 armnn::IWorkloadFactory& workloadFactory,
662 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
663 bool useSubtensor);
664
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]665LayerTestResult<uint8_t, 4> SimpleSigmoidUint8Test(
666 armnn::IWorkloadFactory& workloadFactory,
667 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
668
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]669LayerTestResult<int16_t, 4> SimpleSigmoidInt16Test(
670 armnn::IWorkloadFactory& workloadFactory,
671 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
672
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]673LayerTestResult<float, 4> CompareConvolution2dTest(
674 armnn::IWorkloadFactory& workloadFactory,
675 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]676 armnn::IWorkloadFactory& refWorkloadFactory);
677
678template<typename T>
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]679LayerTestResult<T, 4> CompareDepthwiseConvolution2dTest(
680 armnn::IWorkloadFactory& workloadFactory,
681 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
682 armnn::IWorkloadFactory& refWorkloadFactory,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]683 const armnn::DataLayout layout);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]684
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]685LayerTestResult<float, 4> CompareNormalizationTest(
686 armnn::IWorkloadFactory& workloadFactory,
687 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
688 armnn::IWorkloadFactory& refWorkloadFactory,
689 armnn::NormalizationAlgorithmChannel normChannel,
690 armnn::NormalizationAlgorithmMethod normMethod);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]691
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]692LayerTestResult<float, 2> CompareSoftmaxTest(
693 armnn::IWorkloadFactory& workloadFactory,
694 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]695 armnn::IWorkloadFactory& refWorkloadFactory,
696 float beta);
697
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]698LayerTestResult<float, 2> FullyConnectedFloat32Test(
699 armnn::IWorkloadFactory& workloadFactory,
700 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
701 bool biasEnabled,
702 bool transposeWeights);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]703
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]704std::vector<LayerTestResult<float, 3>> SplitterTest(
705 armnn::IWorkloadFactory& workloadFactory,
706 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
David Beck5cd01f32018-09-12 16:00:08 +0100[diff] [blame]707
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]708LayerTestResult<float, 3> CopyViaSplitterTest(
709 armnn::IWorkloadFactory& workloadFactory,
710 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]711
Jim Flynn4ed6c832019-05-20 11:02:46 +0100[diff] [blame]712LayerTestResult<float, 3> ConcatTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]713 armnn::IWorkloadFactory& workloadFactory,
714 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]715
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]716LayerTestResult<float, 4> AdditionTest(
717 armnn::IWorkloadFactory& workloadFactory,
718 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]719
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]720LayerTestResult<float, 5> Addition5dTest(
721 armnn::IWorkloadFactory& workloadFactory,
722 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
723
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]724LayerTestResult<float, 4> AdditionBroadcast1ElementTest(
725 armnn::IWorkloadFactory& workloadFactory,
726 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]727
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]728LayerTestResult<float, 4> AdditionBroadcastTest(
729 armnn::IWorkloadFactory& workloadFactory,
730 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]731
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]732LayerTestResult<float, 4> CompareAdditionTest(
733 armnn::IWorkloadFactory& workloadFactory,
734 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
735 armnn::IWorkloadFactory& refWorkloadFactory);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]736
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]737LayerTestResult<float, 4> SubtractionTest(
738 armnn::IWorkloadFactory& workloadFactory,
739 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]740
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]741LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(
742 armnn::IWorkloadFactory& workloadFactory,
743 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]744
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]745LayerTestResult<float, 4> SubtractionBroadcastTest(
746 armnn::IWorkloadFactory& workloadFactory,
747 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]748
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]749LayerTestResult<float, 4> CompareActivationTest(
750 armnn::IWorkloadFactory& workloadFactory,
751 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
752 armnn::IWorkloadFactory& refWorkloadFactory,
753 armnn::ActivationFunction f,
754 unsigned int batchSize);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]755
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]756LayerTestResult<float, 4> DivisionTest(
757 armnn::IWorkloadFactory& workloadFactory,
758 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]759
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]760LayerTestResult<float, 4> DivisionByZeroTest(
761 armnn::IWorkloadFactory& workloadFactory,
762 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mohamed Nour Abouelseoud7420e552018-10-12 12:26:24 +0100[diff] [blame]763
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]764LayerTestResult<float, 4> DivisionBroadcast1ElementTest(
765 armnn::IWorkloadFactory& workloadFactory,
766 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mohamed Nour Abouelseoud7420e552018-10-12 12:26:24 +0100[diff] [blame]767
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]768LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(
769 armnn::IWorkloadFactory& workloadFactory,
770 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]771
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]772LayerTestResult<float, 4> MultiplicationTest(
773 armnn::IWorkloadFactory& workloadFactory,
774 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]775
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]776LayerTestResult<float, 5> Multiplication5dTest(
777 armnn::IWorkloadFactory& workloadFactory,
778 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
779
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]780LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(
781 armnn::IWorkloadFactory& workloadFactory,
782 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]783
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]784LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(
785 armnn::IWorkloadFactory& workloadFactory,
786 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]787
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]788LayerTestResult<float, 4> CompareMultiplicationTest(
789 armnn::IWorkloadFactory& workloadFactory,
790 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
791 armnn::IWorkloadFactory& refWorkloadFactory);
Matteo Martincigh28dcab62018-10-19 16:40:03 +0100[diff] [blame]792
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]793LayerTestResult<float, 4> BatchNormTest(
794 armnn::IWorkloadFactory& workloadFactory,
795 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]796
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]797LayerTestResult<float, 4> BatchNormNhwcTest(
798 armnn::IWorkloadFactory& workloadFactory,
799 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]800
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]801LayerTestResult<float, 4> CompareBatchNormTest(
802 armnn::IWorkloadFactory& workloadFactory,
803 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
804 armnn::IWorkloadFactory& refWorkloadFactory);
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]805
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]806LayerTestResult<float, 4> BoundedReLuUpperAndLowerBoundTest(
807 armnn::IWorkloadFactory& workloadFactory,
808 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]809
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]810LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperAndLowerBoundTest(
811 armnn::IWorkloadFactory& workloadFactor,
812 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManagery);
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]813
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]814LayerTestResult<float, 4> BoundedReLuUpperBoundOnlyTest(
815 armnn::IWorkloadFactory& workloadFactory,
816 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]817
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]818LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperBoundOnlyTest(
819 armnn::IWorkloadFactory& workloadFactory,
820 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Éanna Ó Catháin262553e2018-11-14 11:26:23 +0000[diff] [blame]821
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]822LayerTestResult<float, 4> CompareBoundedReLuTest(
823 armnn::IWorkloadFactory& workloadFactory,
824 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
825 armnn::IWorkloadFactory& refWorkloadFactory,
826 float upperBound,
827 float lowerBound);
828
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]829LayerTestResult<float, 4> ReLuTest(
830 armnn::IWorkloadFactory& workloadFactory,
831 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
832
833LayerTestResult<uint8_t, 4> ReLuUint8Test(
834 armnn::IWorkloadFactory& workloadFactory,
835 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]836
837LayerTestResult<int16_t, 4> ReLuInt16Test(
838 armnn::IWorkloadFactory& workloadFactory,
839 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
840
841LayerTestResult<int16_t, 4> BoundedReLuInt16Test(
842 armnn::IWorkloadFactory& workloadFactory,
843 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
844
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]845LayerTestResult<float, 4> SoftReLuTest(
846 armnn::IWorkloadFactory& workloadFactory,
847 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
848
849LayerTestResult<uint8_t, 4> SoftReLuUint8Test(
850 armnn::IWorkloadFactory& workloadFactory,
851 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
852
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]853LayerTestResult<int16_t, 4> SoftReLuInt16Test(
854 armnn::IWorkloadFactory& workloadFactory,
855 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
856
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]857LayerTestResult<float, 4> LeakyReLuTest(
858 armnn::IWorkloadFactory& workloadFactory,
859 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
860
861LayerTestResult<uint8_t, 4> LeakyReLuUint8Test(
862 armnn::IWorkloadFactory& workloadFactory,
863 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
864
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]865LayerTestResult<int16_t, 4> LeakyReLuInt16Test(
866 armnn::IWorkloadFactory& workloadFactory,
867 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
868
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]869LayerTestResult<float, 4> AbsTest(
870 armnn::IWorkloadFactory& workloadFactory,
871 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
872
873LayerTestResult<uint8_t, 4> AbsUint8Test(
874 armnn::IWorkloadFactory& workloadFactory,
875 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
876
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]877LayerTestResult<int16_t, 4> AbsInt16Test(
878 armnn::IWorkloadFactory& workloadFactory,
879 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
880
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]881LayerTestResult<float, 4> SqrtTest(
882 armnn::IWorkloadFactory& workloadFactory,
883 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
884
885LayerTestResult<uint8_t, 4> SqrtUint8Test(
886 armnn::IWorkloadFactory& workloadFactory,
887 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
888
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]889LayerTestResult<int16_t, 4> SqrtInt16Test(
890 armnn::IWorkloadFactory& workloadFactory,
891 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
892
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]893LayerTestResult<float, 4> SquareTest(
894 armnn::IWorkloadFactory& workloadFactory,
895 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
896
897LayerTestResult<uint8_t, 4> SquareUint8Test(
898 armnn::IWorkloadFactory& workloadFactory,
899 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
900
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]901LayerTestResult<int16_t, 4> SquareInt16Test(
902 armnn::IWorkloadFactory& workloadFactory,
903 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
904
konsof017f6db402019-06-07 15:15:58 +0100[diff] [blame]905LayerTestResult<float, 4> TanhTest(
906 armnn::IWorkloadFactory& workloadFactory,
907 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
908
909LayerTestResult<uint8_t, 4> TanhUint8Test(
910 armnn::IWorkloadFactory& workloadFactory,
911 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
912
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]913LayerTestResult<int16_t, 4> TanhInt16Test(
914 armnn::IWorkloadFactory& workloadFactory,
915 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
916
917
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]918// Tests that the output should be identical to the input when the output dimensions match the input ones.
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]919template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
920LayerTestResult<T, 4> ResizeBilinearNopTest(
921 armnn::IWorkloadFactory& workloadFactory,
922 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
923 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]924
925// Tests the behaviour of the resize bilinear operation when rescaling a 2x2 image into a 1x1 image.
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]926template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
927LayerTestResult<T, 4> SimpleResizeBilinearTest(
928 armnn::IWorkloadFactory& workloadFactory,
929 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
930 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]931
932// Tests the resize bilinear for minification of a square input matrix (also: input dimensions are a
933// multiple of output dimensions).
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]934template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
935LayerTestResult<T, 4> ResizeBilinearSqMinTest(
936 armnn::IWorkloadFactory& workloadFactory,
937 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
938 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]939
940// Tests the resize bilinear for minification (output dimensions smaller than input dimensions).
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]941template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
942LayerTestResult<T, 4> ResizeBilinearMinTest(
943 armnn::IWorkloadFactory& workloadFactory,
944 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
945 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]946
947// Tests the resize bilinear for magnification (output dimensions bigger than input dimensions).
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]948template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
949LayerTestResult<T, 4> ResizeBilinearMagTest(
950 armnn::IWorkloadFactory& workloadFactory,
951 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
952 const armnn::DataLayout dataLayout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]953
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]954// Tests that the output should be identical to the input when the output dimensions match the input ones.
955template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
956LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
957 armnn::IWorkloadFactory& workloadFactory,
958 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
959 const armnn::DataLayout dataLayout);
960
961// Tests the behaviour of the resize NearestNeighbor operation when rescaling a 2x2 image into a 1x1 image.
962template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
963LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
964 armnn::IWorkloadFactory& workloadFactory,
965 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
966 const armnn::DataLayout dataLayout);
967
968// Tests the resize NearestNeighbor for minification of a square input matrix (also: input dimensions are a
969// multiple of output dimensions).
970template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
971LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
972 armnn::IWorkloadFactory& workloadFactory,
973 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
974 const armnn::DataLayout dataLayout);
975
976// Tests the resize NearestNeighbor for minification (output dimensions smaller than input dimensions).
977template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
978LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
979 armnn::IWorkloadFactory& workloadFactory,
980 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
981 const armnn::DataLayout dataLayout);
982
983// Tests the resize NearestNeighbor for magnification (output dimensions bigger than input dimensions).
984template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
985LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
986 armnn::IWorkloadFactory& workloadFactory,
987 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]988 const armnn::DataLayout dataLayout,
989 float inQuantScale,
990 int32_t inQuantOffset,
991 float outQuantScale,
992 int32_t outQuantOffset);
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]993
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]994template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
995LayerTestResult<T, 2> Rsqrt2dTestCommon(
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]996 armnn::IWorkloadFactory& workloadFactory,
997 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
998 const armnn::TensorInfo inputTensorInfo,
999 const armnn::TensorInfo outputTensorInfo,
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]1000 const std::vector<float>& inputValues,
1001 const std::vector<float>& expectedOutputValues);
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1002
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]1003template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1004LayerTestResult<T, 2> Rsqrt2dTest(
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1005 armnn::IWorkloadFactory& workloadFactory,
1006 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1007
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]1008template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1009LayerTestResult<T, 3> Rsqrt3dTest(
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1010 armnn::IWorkloadFactory& workloadFactory,
1011 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1012
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]1013template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1014LayerTestResult<T, 2> RsqrtZeroTest(
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1015 armnn::IWorkloadFactory& workloadFactory,
1016 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1017
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]1018template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1019LayerTestResult<T, 2> RsqrtNegativeTest(
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1020 armnn::IWorkloadFactory& workloadFactory,
1021 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1022
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1023LayerTestResult<float, 4> BatchNormTest(
1024 armnn::IWorkloadFactory& workloadFactory,
1025 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1026
1027LayerTestResult<float, 4> BatchNormNhwcTest(
1028 armnn::IWorkloadFactory& workloadFactory,
1029 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1030
1031LayerTestResult<float, 2> FakeQuantizationTest(
1032 armnn::IWorkloadFactory& workloadFactory,
1033 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1034
Ferran Balaguere52211e2019-06-17 12:23:52 +0100[diff] [blame]1035LayerTestResult<float, 4> L2NormalizationDefaultEpsilonTest(
1036 armnn::IWorkloadFactory& workloadFactory,
1037 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1038 const armnn::DataLayout layout);
1039
1040LayerTestResult<float, 4> L2NormalizationNonDefaultEpsilonTest(
1041 armnn::IWorkloadFactory& workloadFactory,
1042 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1043 const armnn::DataLayout layout);
1044
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1045LayerTestResult<float, 4> L2Normalization1dTest(
1046 armnn::IWorkloadFactory& workloadFactory,
1047 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1048 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1049
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1050LayerTestResult<int16_t, 4> L2Normalization1dInt16Test(
1051 armnn::IWorkloadFactory& workloadFactory,
1052 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1053 const armnn::DataLayout layout);
1054
Ferran Balaguerc6138d82019-06-13 17:23:50 +0100[diff] [blame]1055LayerTestResult<uint8_t, 4> L2Normalization1dUint8Test(
1056 armnn::IWorkloadFactory& workloadFactory,
1057 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1058 const armnn::DataLayout layout);
1059
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1060LayerTestResult<float, 4> L2Normalization2dTest(
1061 armnn::IWorkloadFactory& workloadFactory,
1062 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1063 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1064
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1065LayerTestResult<int16_t, 4> L2Normalization2dInt16Test(
1066 armnn::IWorkloadFactory& workloadFactory,
1067 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1068 const armnn::DataLayout layout);
1069
Ferran Balaguerc6138d82019-06-13 17:23:50 +0100[diff] [blame]1070LayerTestResult<uint8_t, 4> L2Normalization2dUint8Test(
1071 armnn::IWorkloadFactory& workloadFactory,
1072 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1073 const armnn::DataLayout layout);
1074
Matthew Jackson82b15ed2019-07-25 16:14:30 +0100[diff] [blame]1075LayerTestResult<float, 2> L2Normalization2dShapeTest(
1076 armnn::IWorkloadFactory& workloadFactory,
1077 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1078
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1079LayerTestResult<float, 4> L2Normalization3dTest(
1080 armnn::IWorkloadFactory& workloadFactory,
1081 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1082 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1083
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1084LayerTestResult<int16_t, 4> L2Normalization3dInt16Test(
1085 armnn::IWorkloadFactory& workloadFactory,
1086 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1087 const armnn::DataLayout layout);
1088
Ferran Balaguerc6138d82019-06-13 17:23:50 +0100[diff] [blame]1089LayerTestResult<uint8_t, 4> L2Normalization3dUint8Test(
1090 armnn::IWorkloadFactory& workloadFactory,
1091 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1092 const armnn::DataLayout layout);
1093
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1094LayerTestResult<float, 4> L2Normalization4dTest(
1095 armnn::IWorkloadFactory& workloadFactory,
1096 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1097 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1098
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1099LayerTestResult<int16_t, 4> L2Normalization4dInt16Test(
1100 armnn::IWorkloadFactory& workloadFactory,
1101 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1102 const armnn::DataLayout layout);
1103
Ferran Balaguerc6138d82019-06-13 17:23:50 +0100[diff] [blame]1104LayerTestResult<uint8_t, 4> L2Normalization4dUint8Test(
1105 armnn::IWorkloadFactory& workloadFactory,
1106 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1107 const armnn::DataLayout layout);
1108
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1109LayerTestResult<float, 4> ConstantTest(
1110 armnn::IWorkloadFactory& workloadFactory,
1111 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1112
Nina Drozd58ef2c62019-05-16 12:09:18 +0100[diff] [blame]1113LayerTestResult<uint8_t, 4> ConstantUint8SimpleQuantizationScaleNoOffsetTest(
1114 armnn::IWorkloadFactory& workloadFactory,
1115 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1116
1117LayerTestResult<int16_t, 4> ConstantInt16SimpleQuantizationScaleNoOffsetTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1118 armnn::IWorkloadFactory& workloadFactory,
1119 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1120
1121LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(
1122 armnn::IWorkloadFactory& workloadFactory,
1123 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1124 float upperBound);
1125
1126LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(
1127 armnn::IWorkloadFactory& workloadFactory,
1128 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1129 float upperBound,
1130 float lowerBound);
1131
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1132template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1133LayerTestResult<T, 2> FullyConnectedTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1134 armnn::IWorkloadFactory& workloadFactory,
1135 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1136 bool biasEnabled);
1137
1138std::vector<LayerTestResult<uint8_t, 3>> SplitterUint8Test(
1139 armnn::IWorkloadFactory& workloadFactory,
1140 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1141
Ruomei Yan25339c32019-05-28 16:48:20 +0100[diff] [blame]1142std::vector<LayerTestResult<int16_t, 3>> SplitterInt16Test(
1143 armnn::IWorkloadFactory& workloadFactory,
1144 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1145
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1146LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(
1147 armnn::IWorkloadFactory& workloadFactory,
1148 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1149
Ruomei Yan25339c32019-05-28 16:48:20 +0100[diff] [blame]1150LayerTestResult<int16_t, 3> CopyViaSplitterInt16Test(
1151 armnn::IWorkloadFactory& workloadFactory,
1152 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1153
Jim Flynn4ed6c832019-05-20 11:02:46 +0100[diff] [blame]1154LayerTestResult<uint8_t, 3> ConcatUint8Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1155 armnn::IWorkloadFactory& workloadFactory,
1156 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1157
Jim Flynn4ed6c832019-05-20 11:02:46 +0100[diff] [blame]1158LayerTestResult<uint16_t, 3> ConcatUint16Test(
Jim Flynncbb66aa2019-05-15 13:03:54 +0100[diff] [blame]1159 armnn::IWorkloadFactory& workloadFactory,
1160 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1161
Jim Flynn4ed6c832019-05-20 11:02:46 +0100[diff] [blame]1162LayerTestResult<uint8_t, 3> ConcatUint8DifferentQParamsTest(
Jim Flynncbb66aa2019-05-15 13:03:54 +0100[diff] [blame]1163 armnn::IWorkloadFactory& workloadFactory,
1164 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Ferran Balaguerb2845652019-02-27 09:42:06 +0000[diff] [blame]1165
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1166LayerTestResult<uint8_t, 4> AdditionUint8Test(
1167 armnn::IWorkloadFactory& workloadFactory,
1168 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1169
1170LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(
1171 armnn::IWorkloadFactory& workloadFactory,
1172 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1173
1174LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(
1175 armnn::IWorkloadFactory& workloadFactory,
1176 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1177
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1178LayerTestResult<int16_t, 4> AdditionInt16Test(
1179 armnn::IWorkloadFactory& workloadFactory,
1180 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1181
1182LayerTestResult<int16_t, 4> AdditionBroadcastInt16Test(
1183 armnn::IWorkloadFactory& workloadFactory,
1184 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1185
1186LayerTestResult<int16_t, 4> AdditionBroadcast1ElementInt16Test(
1187 armnn::IWorkloadFactory& workloadFactory,
1188 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1189
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1190LayerTestResult<uint8_t, 4> SubtractionUint8Test(
1191 armnn::IWorkloadFactory& workloadFactory,
1192 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1193
1194LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(
1195 armnn::IWorkloadFactory& workloadFactory,
1196 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1197
1198LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(
1199 armnn::IWorkloadFactory& workloadFactory,
1200 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1201
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1202LayerTestResult<int16_t, 4> SubtractionInt16Test(
1203 armnn::IWorkloadFactory& workloadFactory,
1204 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1205
1206LayerTestResult<int16_t, 4> SubtractionBroadcast1ElementInt16Test(
1207 armnn::IWorkloadFactory& workloadFactory,
1208 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1209
1210LayerTestResult<int16_t, 4> SubtractionBroadcastInt16Test(
1211 armnn::IWorkloadFactory& workloadFactory,
1212 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1213
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1214LayerTestResult<uint8_t, 4> CompareActivationUint8Test(
1215 armnn::IWorkloadFactory& workloadFactory,
1216 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1217 armnn::IWorkloadFactory& refWorkloadFactory,
1218 armnn::ActivationFunction f);
1219
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]1220LayerTestResult<int16_t, 4> CompareActivationInt16Test(
1221 armnn::IWorkloadFactory& workloadFactory,
1222 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1223 armnn::IWorkloadFactory& refWorkloadFactory,
1224 armnn::ActivationFunction f);
1225
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1226LayerTestResult<uint8_t, 2> CompareSoftmaxUint8Test(
1227 armnn::IWorkloadFactory& workloadFactory,
1228 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1229 armnn::IWorkloadFactory& refWorkloadFactory,
1230 float beta);
1231
1232LayerTestResult<uint8_t, 4> MultiplicationUint8Test(
1233 armnn::IWorkloadFactory& workloadFactory,
1234 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1235
1236LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(
1237 armnn::IWorkloadFactory& workloadFactory,
1238 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1239
1240LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(
1241 armnn::IWorkloadFactory& workloadFactory,
1242 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1243
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1244LayerTestResult<int16_t, 4> MultiplicationInt16Test(
1245 armnn::IWorkloadFactory& workloadFactory,
1246 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1247
1248LayerTestResult<int16_t, 4> MultiplicationBroadcast1ElementInt16Test(
1249 armnn::IWorkloadFactory& workloadFactory,
1250 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1251
1252LayerTestResult<int16_t, 4> MultiplicationBroadcast1DVectorInt16Test(
1253 armnn::IWorkloadFactory& workloadFactory,
1254 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1255
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1256LayerTestResult<uint8_t, 4> DivisionUint8Test(
1257 armnn::IWorkloadFactory& workloadFactory,
1258 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1259
1260LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(
1261 armnn::IWorkloadFactory& workloadFactory,
1262 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1263
1264LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(
1265 armnn::IWorkloadFactory& workloadFactory,
1266 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1267
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1268LayerTestResult<int16_t, 4> DivisionInt16Test(
1269 armnn::IWorkloadFactory& workloadFactory,
1270 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1271
1272LayerTestResult<int16_t, 4> DivisionBroadcast1ElementInt16Test(
1273 armnn::IWorkloadFactory& workloadFactory,
1274 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1275
1276LayerTestResult<int16_t, 4> DivisionBroadcast1DVectorInt16Test(
1277 armnn::IWorkloadFactory& workloadFactory,
1278 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1279
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1280LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(
1281 armnn::IWorkloadFactory& workloadFactory,
1282 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1283 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1284 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1285
1286LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(
1287 armnn::IWorkloadFactory& workloadFactory,
1288 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1289 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1290 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1291
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]1292LayerTestResult<int16_t, 4> SimpleConvolution2d3x5QSymm16Test(
1293 armnn::IWorkloadFactory& workloadFactory,
1294 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1295 bool biasEnabled,
1296 const armnn::DataLayout layout);
1297
1298LayerTestResult<int16_t, 4> SimpleConvolution2d3x3QSymm16Test(
1299 armnn::IWorkloadFactory& workloadFactory,
1300 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1301 bool biasEnabled,
1302 const armnn::DataLayout layout);
1303
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1304LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(
1305 armnn::IWorkloadFactory& workloadFactory,
1306 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1307 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1308 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1309
1310LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(
1311 armnn::IWorkloadFactory& workloadFactory,
1312 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1313 bool biasEnabled,
Matthew Bentham8800c002018-11-19 13:19:28 +0000[diff] [blame]1314 const armnn::DataLayout layout);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1315
Ruomei Yan88d44b82019-05-23 14:29:06 +0100[diff] [blame]1316LayerTestResult<int16_t, 4> DepthwiseConvolution2dInt16Test(
1317 armnn::IWorkloadFactory& workloadFactory,
1318 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1319 bool biasEnabled,
1320 const armnn::DataLayout layout);
1321
1322LayerTestResult<int16_t, 4> DepthwiseConvolution2dDepthMul1Int16Test(
1323 armnn::IWorkloadFactory& workloadFactory,
1324 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1325 bool biasEnabled,
1326 const armnn::DataLayout layout);
1327
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1328LayerTestResult<uint8_t, 4> ConstantLinearActivationUint8Test(
1329 armnn::IWorkloadFactory& workloadFactory,
1330 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1331
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]1332LayerTestResult<int16_t, 4> ConstantLinearActivationInt16Test(
1333 armnn::IWorkloadFactory& workloadFactory,
1334 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1335
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1336LayerTestResult<uint8_t, 4> BatchNormUint8Test(
1337 armnn::IWorkloadFactory& workloadFactory,
1338 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1339
1340LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(
1341 armnn::IWorkloadFactory& workloadFactory,
1342 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1343
Matteo Martincighf5507132019-06-04 10:59:47 +0100[diff] [blame]1344LayerTestResult<int16_t, 4> BatchNormInt16Test(
1345 armnn::IWorkloadFactory& workloadFactory,
1346 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1347
1348LayerTestResult<int16_t, 4> BatchNormInt16NhwcTest(
1349 armnn::IWorkloadFactory& workloadFactory,
1350 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1351
Nina Drozd58ef2c62019-05-16 12:09:18 +0100[diff] [blame]1352LayerTestResult<uint8_t, 4> ConstantUint8CustomQuantizationScaleAndOffsetTest(
1353 armnn::IWorkloadFactory& workloadFactory,
1354 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1355
1356LayerTestResult<int16_t, 4> ConstantInt16CustomQuantizationScaleAndOffsetTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1357 armnn::IWorkloadFactory& workloadFactory,
1358 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1359
1360LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(
1361 armnn::IWorkloadFactory& workloadFactory,
1362 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1363
1364LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(
1365 armnn::IWorkloadFactory& workloadFactory,
1366 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1367
1368LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(
1369 armnn::IWorkloadFactory& workloadFactory,
1370 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1371
1372LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(
1373 armnn::IWorkloadFactory& workloadFactory,
1374 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1375
1376LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(
1377 armnn::IWorkloadFactory& workloadFactory,
1378 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1379
1380LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(
1381 armnn::IWorkloadFactory& workloadFactory,
1382 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1383
1384LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(
1385 armnn::IWorkloadFactory& workloadFactory,
1386 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1387
1388LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(
1389 armnn::IWorkloadFactory& workloadFactory,
narpra015cdda352018-11-19 15:30:27 +0000[diff] [blame]1390 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1391 bool useSubtensor);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1392
1393LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(
1394 armnn::IWorkloadFactory& workloadFactory,
1395 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1396
1397LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(
1398 armnn::IWorkloadFactory& workloadFactory,
1399 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1400
1401LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(
1402 armnn::IWorkloadFactory& workloadFactory,
narpra015cdda352018-11-19 15:30:27 +0000[diff] [blame]1403 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1404 bool useSubtensor);
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1405
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]1406LayerTestResult<uint8_t, 4> EqualSimpleTest(
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]1407 armnn::IWorkloadFactory& workloadFactory,
1408 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1409
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]1410LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]1411 armnn::IWorkloadFactory& workloadFactory,
1412 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1413
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]1414LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorTest(
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]1415 armnn::IWorkloadFactory& workloadFactory,
1416 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1417
1418LayerTestResult<uint8_t, 4> EqualUint8Test(
1419 armnn::IWorkloadFactory& workloadFactory,
1420 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1421
1422LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
1423 armnn::IWorkloadFactory& workloadFactory,
1424 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1425
1426LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorUint8Test(
1427 armnn::IWorkloadFactory& workloadFactory,
1428 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1429
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]1430LayerTestResult<uint8_t, 4> GreaterSimpleTest(
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]1431 armnn::IWorkloadFactory& workloadFactory,
1432 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1433
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]1434LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]1435 armnn::IWorkloadFactory& workloadFactory,
1436 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1437
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]1438LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorTest(
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]1439 armnn::IWorkloadFactory& workloadFactory,
1440 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1441
1442LayerTestResult<uint8_t, 4> GreaterUint8Test(
1443 armnn::IWorkloadFactory& workloadFactory,
1444 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1445
1446LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
1447 armnn::IWorkloadFactory& workloadFactory,
1448 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1449
1450LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorUint8Test(
1451 armnn::IWorkloadFactory& workloadFactory,
1452 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1453
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1454LayerTestResult<float, 2> FullyConnectedLargeTest(
1455 armnn::IWorkloadFactory& workloadFactory,
1456 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1457 bool transposeWeights);
1458
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1459LayerTestResult<uint8_t, 2> PadUint82dTest(
1460 armnn::IWorkloadFactory& workloadFactory,
1461 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1462
David Monahan34757812019-06-19 11:47:21 +0100[diff] [blame]1463LayerTestResult<uint8_t, 2> PadUint82dCustomPaddingTest(
1464 armnn::IWorkloadFactory& workloadFactory,
1465 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1466
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1467LayerTestResult<uint8_t, 3> PadUint83dTest(
1468 armnn::IWorkloadFactory& workloadFactory,
1469 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1470
1471LayerTestResult<uint8_t, 4> PadUint84dTest(
1472 armnn::IWorkloadFactory& workloadFactory,
1473 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1474
1475LayerTestResult<float, 2> PadFloat322dTest(
1476 armnn::IWorkloadFactory& workloadFactory,
1477 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1478
David Monahan34757812019-06-19 11:47:21 +0100[diff] [blame]1479LayerTestResult<float, 2> PadFloat322dCustomPaddingTest(
1480 armnn::IWorkloadFactory& workloadFactory,
1481 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1482
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1483LayerTestResult<float, 3> PadFloat323dTest(
1484 armnn::IWorkloadFactory& workloadFactory,
1485 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1486
1487LayerTestResult<float, 4> PadFloat324dTest(
1488 armnn::IWorkloadFactory& workloadFactory,
1489 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1490
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1491template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1492LayerTestResult<T, 2> Pad2dTestCommon(
1493 armnn::IWorkloadFactory& workloadFactory,
1494 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1495 float qScale,
1496 int32_t qOffset,
1497 const float customPaddingValue = 0.0f);
1498
1499template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1500LayerTestResult<T, 3> Pad3dTestCommon(
1501 armnn::IWorkloadFactory& workloadFactory,
1502 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1503 float qScale,
1504 int32_t qOffset);
1505
1506template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1507LayerTestResult<T, 4> Pad4dTestCommon(
1508 armnn::IWorkloadFactory& workloadFactory,
1509 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1510 float qScale,
1511 int32_t qOffset);
1512
Jan Eilers38e05bd2019-06-26 13:10:09 +0100[diff] [blame]1513void LstmUtilsZeroVectorTest();
1514void LstmUtilsMeanStddevNormalizationNoneZeroInputTest();
1515void LstmUtilsMeanStddevNormalizationAllZeroInputTest();
1516void LstmUtilsMeanStddevNormalizationMixedZeroInputTest();
1517void LstmUtilsVectorBatchVectorCwiseProductTest();
1518void LstmUtilsVectorBatchVectorAddTest();
1519
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1520LayerTestResult<float, 2> LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest(
1521 armnn::IWorkloadFactory& workloadFactory,
1522 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1523
1524LayerTestResult<float, 2> LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(
1525 armnn::IWorkloadFactory& workloadFactory,
1526 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1527
1528LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest(
1529 armnn::IWorkloadFactory& workloadFactory,
1530 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1531
Jan Eilers38e05bd2019-06-26 13:10:09 +0100[diff] [blame]1532LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNormTest(
1533 armnn::IWorkloadFactory& workloadFactory,
1534 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1535
Conor Kennedyb9971c92019-05-07 07:14:23 +0100[diff] [blame]1536LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgNoPeepholeNoProjectionTest(
1537 armnn::IWorkloadFactory& workloadFactory,
1538 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1539
1540LayerTestResult<int16_t, 2> LstmLayerInt16WithCifgWithPeepholeNoProjectionTest(
1541 armnn::IWorkloadFactory& workloadFactory,
1542 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1543
1544LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgWithPeepholeWithProjectionTest(
1545 armnn::IWorkloadFactory& workloadFactory,
1546 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1547
1548LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest(
1549 armnn::IWorkloadFactory& workloadFactory,
1550 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1551
James Conroy9c3cae82019-08-01 16:01:48 +0100[diff] [blame]1552// QuantizedLstm
1553LayerTestResult<uint8_t, 2> QuantizedLstmTest(
1554 armnn::IWorkloadFactory& workloadFactory,
1555 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1556
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1557LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(
1558 armnn::IWorkloadFactory& workloadFactory,
1559 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1560
1561LayerTestResult<armnn::Half, 4> SimpleConvertFp32ToFp16Test(
1562 armnn::IWorkloadFactory& workloadFactory,
1563 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1564
Éanna Ó Catháinde705582018-12-03 13:04:22 +0000[diff] [blame]1565LayerTestResult<float, 4> MaximumSimpleTest(
1566 armnn::IWorkloadFactory& workloadFactory,
1567 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1568
1569LayerTestResult<float, 4> MaximumBroadcast1ElementTest(
1570 armnn::IWorkloadFactory& workloadFactory,
1571 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1572
1573LayerTestResult<float, 4> MaximumBroadcast1DVectorTest(
1574 armnn::IWorkloadFactory& workloadFactory,
1575 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1576
1577LayerTestResult<uint8_t , 4> MaximumUint8Test(
1578 armnn::IWorkloadFactory& workloadFactory,
1579 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1580
1581LayerTestResult<uint8_t, 4> MaximumBroadcast1ElementUint8Test(
1582 armnn::IWorkloadFactory& workloadFactory,
1583 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1584
1585LayerTestResult<uint8_t, 4> MaximumBroadcast1DVectorUint8Test(
1586 armnn::IWorkloadFactory& workloadFactory,
1587 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1588
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1589LayerTestResult<int16_t , 4> MaximumInt16Test(
1590 armnn::IWorkloadFactory& workloadFactory,
1591 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1592
1593LayerTestResult<int16_t, 4> MaximumBroadcast1ElementInt16Test(
1594 armnn::IWorkloadFactory& workloadFactory,
1595 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1596
1597LayerTestResult<int16_t, 4> MaximumBroadcast1DVectorInt16Test(
1598 armnn::IWorkloadFactory& workloadFactory,
1599 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1600
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1601template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1602LayerTestResult<T, 1> MeanSimpleTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1603 armnn::IWorkloadFactory& workloadFactory,
1604 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1605
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1606template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1607LayerTestResult<T, 3> MeanSimpleAxisTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1608 armnn::IWorkloadFactory& workloadFactory,
1609 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1610
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1611template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1612LayerTestResult<T, 4> MeanKeepDimsTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1613 armnn::IWorkloadFactory& workloadFactory,
1614 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1615
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1616template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1617LayerTestResult<T, 4> MeanMultipleDimsTest(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1618 armnn::IWorkloadFactory& workloadFactory,
1619 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1620
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1621template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1622LayerTestResult<T, 1> MeanVts1Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1623 armnn::IWorkloadFactory& workloadFactory,
1624 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1625
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1626template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1627LayerTestResult<T, 3> MeanVts2Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1628 armnn::IWorkloadFactory& workloadFactory,
1629 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1630
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1631template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1632LayerTestResult<T, 3> MeanVts3Test(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1633 armnn::IWorkloadFactory& workloadFactory,
1634 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1635
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]1636LayerTestResult<float, 4> MinimumBroadcast1ElementTest1(
1637 armnn::IWorkloadFactory& workloadFactory,
1638 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1639
1640LayerTestResult<float, 4> MinimumBroadcast1ElementTest2(
1641 armnn::IWorkloadFactory& workloadFactory,
1642 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1643
1644LayerTestResult<uint8_t, 4> MinimumBroadcast1DVectorUint8Test(
1645 armnn::IWorkloadFactory & workloadFactory,
1646 const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager);
1647
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1648LayerTestResult<int16_t , 4> MinimumInt16Test(
1649 armnn::IWorkloadFactory& workloadFactory,
1650 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1651
1652LayerTestResult<int16_t, 4> MinimumBroadcast1ElementInt16Test(
1653 armnn::IWorkloadFactory& workloadFactory,
1654 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1655
1656LayerTestResult<int16_t, 4> MinimumBroadcast1DVectorInt16Test(
1657 armnn::IWorkloadFactory& workloadFactory,
1658 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1659
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1660LayerTestResult<float, 4> AdditionAfterMaxPoolTest(
1661 armnn::IWorkloadFactory& workloadFactory,
1662 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1663
1664LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(
1665 armnn::IWorkloadFactory& workloadFactory,
1666 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1667
1668LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(
1669 armnn::IWorkloadFactory& workloadFactory,
1670 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1671
1672LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(
1673 armnn::IWorkloadFactory& workloadFactory,
1674 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1675
1676LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(
1677 armnn::IWorkloadFactory& workloadFactory,
1678 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1679
1680LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(
1681 armnn::IWorkloadFactory& workloadFactory,
1682 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1683
1684LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(
1685 armnn::IWorkloadFactory& workloadFactory,
1686 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1687
1688LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(
1689 armnn::IWorkloadFactory& workloadFactory,
1690 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1691
1692LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(
1693 armnn::IWorkloadFactory& workloadFactory,
1694 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1695
1696LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(
1697 armnn::IWorkloadFactory& workloadFactory,
1698 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1699
1700LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(
1701 armnn::IWorkloadFactory& workloadFactory,
1702 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1703
1704LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(
1705 armnn::IWorkloadFactory& workloadFactory,
1706 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1707
1708LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(
1709 armnn::IWorkloadFactory& workloadFactory,
1710 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1711
1712LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(
1713 armnn::IWorkloadFactory& workloadFactory,
1714 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1715
1716LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(
1717 armnn::IWorkloadFactory& workloadFactory,
1718 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1719
1720LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(
1721 armnn::IWorkloadFactory& workloadFactory,
1722 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1723
1724LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(
1725 armnn::IWorkloadFactory& workloadFactory,
1726 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1727
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]1728LayerTestResult<int16_t, 4> SpaceToBatchNdSimpleUint16Test(
1729 armnn::IWorkloadFactory& workloadFactory,
1730 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1731
1732LayerTestResult<int16_t, 4> SpaceToBatchNdMultiChannelsUint16Test(
1733 armnn::IWorkloadFactory& workloadFactory,
1734 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1735
1736LayerTestResult<int16_t, 4> SpaceToBatchNdMultiBlockUint16Test(
1737 armnn::IWorkloadFactory& workloadFactory,
1738 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1739
1740LayerTestResult<int16_t, 4> SpaceToBatchNdPaddingUint16Test(
1741 armnn::IWorkloadFactory& workloadFactory,
1742 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1743
1744LayerTestResult<int16_t, 4> SpaceToBatchNdSimpleNHWCUint16Test(
1745 armnn::IWorkloadFactory& workloadFactory,
1746 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1747
1748LayerTestResult<int16_t, 4> SpaceToBatchNdMultiChannelsNHWCUint16Test(
1749 armnn::IWorkloadFactory& workloadFactory,
1750 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1751
1752LayerTestResult<int16_t, 4> SpaceToBatchNdMultiBlockNHWCUint16Test(
1753 armnn::IWorkloadFactory& workloadFactory,
1754 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1755
1756LayerTestResult<int16_t, 4> SpaceToBatchNdPaddingNHWCUint16Test(
1757 armnn::IWorkloadFactory& workloadFactory,
1758 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1759
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1760LayerTestResult<float, 4> BatchToSpaceNdNhwcTest1(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1761 armnn::IWorkloadFactory& workloadFactory,
1762 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1763
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1764LayerTestResult<float, 4> BatchToSpaceNdNhwcTest2(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1765 armnn::IWorkloadFactory& workloadFactory,
1766 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1767
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1768LayerTestResult<float, 4> BatchToSpaceNdNhwcTest3(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1769 armnn::IWorkloadFactory& workloadFactory,
1770 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1771
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1772LayerTestResult<float, 4> BatchToSpaceNdNhwcTest4(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1773 armnn::IWorkloadFactory& workloadFactory,
1774 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1775
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1776LayerTestResult<float, 4> BatchToSpaceNdNchwTest1(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1777 armnn::IWorkloadFactory &workloadFactory,
1778 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1779
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1780LayerTestResult<float, 4> BatchToSpaceNdNchwTest2(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1781 armnn::IWorkloadFactory &workloadFactory,
1782 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1783
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1784LayerTestResult<float, 4> BatchToSpaceNdNchwTest3(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1785 armnn::IWorkloadFactory &workloadFactory,
1786 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1787
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1788LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcTest5(
Aron Virginas-Tar5caf9072018-11-14 18:35:18 +0000[diff] [blame]1789 armnn::IWorkloadFactory &workloadFactory,
1790 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1791
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1792LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcTest6(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1793 armnn::IWorkloadFactory &workloadFactory,
1794 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1795
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1796LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcTest7(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1797 armnn::IWorkloadFactory &workloadFactory,
1798 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1799
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1800LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest4(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1801 armnn::IWorkloadFactory &workloadFactory,
1802 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1803
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1804LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest5(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1805 armnn::IWorkloadFactory &workloadFactory,
1806 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1807
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1808LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest6(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1809 armnn::IWorkloadFactory &workloadFactory,
1810 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1811
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]1812LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest7(
Nattapat Chaimanowong3ee14222019-02-27 10:28:09 +0000[diff] [blame]1813 armnn::IWorkloadFactory &workloadFactory,
1814 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Mike Kelly831faed2018-11-28 11:52:08 +0000[diff] [blame]1815
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1816LayerTestResult<float, 4> StridedSlice4DFloat32Test(
1817 armnn::IWorkloadFactory& workloadFactory,
1818 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]1819
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1820LayerTestResult<float, 4> StridedSlice4DReverseFloat32Test(
1821 armnn::IWorkloadFactory& workloadFactory,
1822 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1823
1824LayerTestResult<float, 4> StridedSliceSimpleStrideFloat32Test(
1825 armnn::IWorkloadFactory& workloadFactory,
1826 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1827
1828LayerTestResult<float, 4> StridedSliceSimpleRangeMaskFloat32Test(
1829 armnn::IWorkloadFactory& workloadFactory,
1830 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1831
1832LayerTestResult<float, 2> StridedSliceShrinkAxisMaskFloat32Test(
1833 armnn::IWorkloadFactory& workloadFactory,
1834 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1835
1836LayerTestResult<float, 3> StridedSlice3DFloat32Test(
1837 armnn::IWorkloadFactory& workloadFactory,
1838 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1839
1840LayerTestResult<float, 3> StridedSlice3DReverseFloat32Test(
1841 armnn::IWorkloadFactory& workloadFactory,
1842 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1843
1844LayerTestResult<float, 2> StridedSlice2DFloat32Test(
1845 armnn::IWorkloadFactory& workloadFactory,
1846 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1847
1848LayerTestResult<float, 2> StridedSlice2DReverseFloat32Test(
1849 armnn::IWorkloadFactory& workloadFactory,
1850 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1851
1852LayerTestResult<uint8_t, 4> StridedSlice4DUint8Test(
1853 armnn::IWorkloadFactory& workloadFactory,
1854 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1855
1856LayerTestResult<uint8_t, 4> StridedSlice4DReverseUint8Test(
1857 armnn::IWorkloadFactory& workloadFactory,
1858 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1859
1860LayerTestResult<uint8_t, 4> StridedSliceSimpleStrideUint8Test(
1861 armnn::IWorkloadFactory& workloadFactory,
1862 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1863
1864LayerTestResult<uint8_t, 4> StridedSliceSimpleRangeMaskUint8Test(
1865 armnn::IWorkloadFactory& workloadFactory,
1866 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1867
1868LayerTestResult<uint8_t, 2> StridedSliceShrinkAxisMaskUint8Test(
1869 armnn::IWorkloadFactory& workloadFactory,
1870 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1871
1872LayerTestResult<uint8_t, 3> StridedSlice3DUint8Test(
1873 armnn::IWorkloadFactory& workloadFactory,
1874 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1875
1876LayerTestResult<uint8_t, 3> StridedSlice3DReverseUint8Test(
1877 armnn::IWorkloadFactory& workloadFactory,
1878 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1879
1880LayerTestResult<uint8_t, 2> StridedSlice2DUint8Test(
1881 armnn::IWorkloadFactory& workloadFactory,
1882 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1883
1884LayerTestResult<uint8_t, 2> StridedSlice2DReverseUint8Test(
1885 armnn::IWorkloadFactory& workloadFactory,
1886 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]1887
Matteo Martincigh42666a12019-05-29 08:53:41 +0100[diff] [blame]1888LayerTestResult<int16_t, 4> StridedSlice4DInt16Test(
1889 armnn::IWorkloadFactory& workloadFactory,
1890 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1891
1892LayerTestResult<int16_t, 4> StridedSlice4DReverseInt16Test(
1893 armnn::IWorkloadFactory& workloadFactory,
1894 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1895
1896LayerTestResult<int16_t, 4> StridedSliceSimpleStrideInt16Test(
1897 armnn::IWorkloadFactory& workloadFactory,
1898 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1899
1900LayerTestResult<int16_t, 4> StridedSliceSimpleRangeMaskInt16Test(
1901 armnn::IWorkloadFactory& workloadFactory,
1902 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1903
1904LayerTestResult<int16_t, 2> StridedSliceShrinkAxisMaskInt16Test(
1905 armnn::IWorkloadFactory& workloadFactory,
1906 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1907
1908LayerTestResult<int16_t, 3> StridedSlice3DInt16Test(
1909 armnn::IWorkloadFactory& workloadFactory,
1910 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1911
1912LayerTestResult<int16_t, 3> StridedSlice3DReverseInt16Test(
1913 armnn::IWorkloadFactory& workloadFactory,
1914 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1915
1916LayerTestResult<int16_t, 2> StridedSlice2DInt16Test(
1917 armnn::IWorkloadFactory& workloadFactory,
1918 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1919
1920LayerTestResult<int16_t, 2> StridedSlice2DReverseInt16Test(
1921 armnn::IWorkloadFactory& workloadFactory,
1922 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1923
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]1924LayerTestResult<float, 4> Debug4DFloat32Test(
1925 armnn::IWorkloadFactory& workloadFactory,
1926 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1927
1928LayerTestResult<float, 3> Debug3DFloat32Test(
1929 armnn::IWorkloadFactory& workloadFactory,
1930 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1931
1932LayerTestResult<float, 2> Debug2DFloat32Test(
1933 armnn::IWorkloadFactory& workloadFactory,
1934 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1935
1936LayerTestResult<float, 1> Debug1DFloat32Test(
1937 armnn::IWorkloadFactory& workloadFactory,
1938 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1939
1940LayerTestResult<uint8_t, 4> Debug4DUint8Test(
1941 armnn::IWorkloadFactory& workloadFactory,
1942 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1943
1944LayerTestResult<uint8_t, 3> Debug3DUint8Test(
1945 armnn::IWorkloadFactory& workloadFactory,
1946 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1947
1948LayerTestResult<uint8_t, 2> Debug2DUint8Test(
1949 armnn::IWorkloadFactory& workloadFactory,
1950 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1951
1952LayerTestResult<uint8_t, 1> Debug1DUint8Test(
1953 armnn::IWorkloadFactory& workloadFactory,
1954 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Matteo Martincigh49124022019-01-11 13:25:59 +0000[diff] [blame]1955
1956LayerTestResult<uint8_t, 4> PreCompiledConvolution2dTest(
1957 armnn::IWorkloadFactory& workloadFactory,
1958 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1959
1960LayerTestResult<uint8_t, 4> PreCompiledConvolution2dStride2x2Test(
1961 armnn::IWorkloadFactory& workloadFactory,
1962 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1963
1964LayerTestResult<uint8_t, 4> PreCompiledDepthwiseConvolution2dTest(
1965 armnn::IWorkloadFactory & workloadFactory,
1966 const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager);
1967
1968LayerTestResult<uint8_t, 4> PreCompiledDepthwiseConvolution2dStride2x2Test(
1969 armnn::IWorkloadFactory & workloadFactory,
1970 const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager);
1971
1972LayerTestResult<uint8_t, 4> PreCompiledMaxPooling2dTest(
1973 armnn::IWorkloadFactory& workloadFactory,
1974 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1975
1976LayerTestResult<float, 4> Debug4DFloat32Test(
1977 armnn::IWorkloadFactory& workloadFactory,
1978 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1979
1980LayerTestResult<float, 3> Debug3DFloat32Test(
1981 armnn::IWorkloadFactory& workloadFactory,
1982 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1983
1984LayerTestResult<float, 2> Debug2DFloat32Test(
1985 armnn::IWorkloadFactory& workloadFactory,
1986 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1987
1988LayerTestResult<float, 1> Debug1DFloat32Test(
1989 armnn::IWorkloadFactory& workloadFactory,
1990 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1991
1992LayerTestResult<uint8_t, 4> Debug4DUint8Test(
1993 armnn::IWorkloadFactory& workloadFactory,
1994 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1995
1996LayerTestResult<uint8_t, 3> Debug3DUint8Test(
1997 armnn::IWorkloadFactory& workloadFactory,
1998 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1999
2000LayerTestResult<uint8_t, 2> Debug2DUint8Test(
2001 armnn::IWorkloadFactory& workloadFactory,
2002 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2003
2004LayerTestResult<uint8_t, 1> Debug1DUint8Test(
2005 armnn::IWorkloadFactory& workloadFactory,
2006 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]2007
2008LayerTestResult<float, 1> Gather1DParamsFloatTest(
2009 armnn::IWorkloadFactory& workloadFactory,
2010 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2011
2012LayerTestResult<uint8_t, 1> Gather1DParamsUint8Test(
2013 armnn::IWorkloadFactory& workloadFactory,
2014 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2015
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]2016LayerTestResult<int16_t, 1> Gather1DParamsInt16Test(
2017 armnn::IWorkloadFactory& workloadFactory,
2018 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2019
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]2020LayerTestResult<float, 2> GatherMultiDimParamsFloatTest(
2021 armnn::IWorkloadFactory& workloadFactory,
2022 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2023
2024LayerTestResult<uint8_t, 2> GatherMultiDimParamsUint8Test(
2025 armnn::IWorkloadFactory& workloadFactory,
2026 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2027
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]2028LayerTestResult<int16_t, 2> GatherMultiDimParamsInt16Test(
2029 armnn::IWorkloadFactory& workloadFactory,
2030 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2031
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]2032LayerTestResult<float, 4> GatherMultiDimParamsMultiDimIndicesFloatTest(
2033 armnn::IWorkloadFactory& workloadFactory,
2034 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2035
2036LayerTestResult<uint8_t, 4> GatherMultiDimParamsMultiDimIndicesUint8Test(
2037 armnn::IWorkloadFactory& workloadFactory,
2038 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]2039
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]2040LayerTestResult<int16_t, 4> GatherMultiDimParamsMultiDimIndicesInt16Test(
2041 armnn::IWorkloadFactory& workloadFactory,
2042 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2043
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]2044LayerTestResult<float, 4> DequantizeSimpleUint8Test(
2045 armnn::IWorkloadFactory& workloadFactory,
2046 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2047
2048LayerTestResult<float, 4> DequantizeOffsetUint8Test(
2049 armnn::IWorkloadFactory& workloadFactory,
2050 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2051
2052LayerTestResult<float, 4> DequantizeSimpleInt16Test(
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]2053 armnn::IWorkloadFactory& workloadFactory,
2054 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Nattapat Chaimanowonga0beb3b2019-04-01 17:04:53 +0100[diff] [blame]2055
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2056LayerTestResult<uint8_t, 4> SpaceToDepthNCHWAsymmQ8Test(
2057 armnn::IWorkloadFactory& workloadFactory,
2058 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2059
2060LayerTestResult<uint8_t, 4> SpaceToDepthNHWCAsymmQ8Test(
2061 armnn::IWorkloadFactory& workloadFactory,
2062 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2063
James Conroyd2aa85e2019-07-01 17:12:40 +0100[diff] [blame]2064LayerTestResult<float, 4> SpaceToDepthNHWCFloat32Test1(
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2065 armnn::IWorkloadFactory& workloadFactory,
2066 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2067
James Conroyd2aa85e2019-07-01 17:12:40 +0100[diff] [blame]2068LayerTestResult<float, 4> SpaceToDepthNCHWFloat32Test1(
2069 armnn::IWorkloadFactory& workloadFactory,
2070 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2071
2072LayerTestResult<float, 4> SpaceToDepthNHWCFloat32Test2(
2073 armnn::IWorkloadFactory& workloadFactory,
2074 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2075
2076LayerTestResult<float, 4> SpaceToDepthNCHWFloat32Test2(
2077 armnn::IWorkloadFactory& workloadFactory,
2078 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2079
2080LayerTestResult<int16_t, 4> SpaceToDepthNHWCQSymm16Test(
2081 armnn::IWorkloadFactory& workloadFactory,
2082 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2083
2084LayerTestResult<int16_t, 4> SpaceToDepthNCHWQSymm16Test(
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2085 armnn::IWorkloadFactory& workloadFactory,
2086 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2087
Nattapat Chaimanowonga0beb3b2019-04-01 17:04:53 +0100[diff] [blame]2088LayerTestResult<uint8_t, 4> QuantizeSimpleUint8Test(
2089 armnn::IWorkloadFactory& workloadFactory,
2090 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2091
2092LayerTestResult<uint8_t, 4> QuantizeClampUint8Test(
2093 armnn::IWorkloadFactory& workloadFactory,
2094 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2095
2096LayerTestResult<int16_t, 4> QuantizeClampInt16Test(
2097 armnn::IWorkloadFactory& workloadFactory,
2098 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2099
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2100template <armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2101std::vector<T> ConvertToDataType(const std::vector<float>& input,
2102 const armnn::TensorInfo& inputTensorInfo)
2103{
2104 std::vector<T> output(input.size());
2105 auto outputTensorInfo = inputTensorInfo;
2106 outputTensorInfo.SetDataType(ArmnnType);
2107
2108 std::unique_ptr<armnn::Encoder<float>> pOutputEncoder = armnn::MakeEncoder<float>(outputTensorInfo, output.data());
2109 armnn::Encoder<float>& rOutputEncoder = *pOutputEncoder;
2110
2111 for (auto it = input.begin(); it != input.end(); ++it)
2112 {
2113 rOutputEncoder.Set(*it);
2114 ++rOutputEncoder;
2115 }
2116 return output;
2117}
2118
2119// Utility method to convert a single value to the correct type
2120template <typename T>
2121T ConvertToDataType(const float& value,
2122 const armnn::TensorInfo& tensorInfo)
2123{
2124 std::vector<T> output(1);
2125 std::unique_ptr<armnn::Encoder<float>> pEncoder = armnn::MakeEncoder<float>(tensorInfo, output.data());
2126 armnn::Encoder<float>& rEncoder = *pEncoder;
2127 rEncoder.Set(value);
2128 return output[0];
2129}
2130
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2131template<typename T, typename B>
2132LayerTestResult<T, 2> SimpleFullyConnectedTestImpl(
2133 armnn::IWorkloadFactory& workloadFactory,
2134 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2135 armnn::TensorInfo inputTensorInfo,
2136 armnn::TensorInfo outputTensorInfo,
2137 armnn::TensorInfo weightsDesc,
2138 armnn::TensorInfo biasesDesc,
2139 boost::multi_array<T, 2>& weights,
2140 boost::multi_array<B, 1>& bias,
2141 boost::multi_array<T, 4>& input,
2142 bool biasEnabled,
2143 bool transposeWeights)
2144{
2145 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2146 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2147
2148 armnn::FullyConnectedQueueDescriptor data;
2149 armnn::WorkloadInfo info;
2150 armnn::ScopedCpuTensorHandle weightsTensor(weightsDesc);
2151 armnn::ScopedCpuTensorHandle biasTensor(biasesDesc);
2152
2153 AllocateAndCopyDataToITensorHandle(&weightsTensor, &weights[0][0]);
2154 AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]);
2155
2156 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
2157 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2158 data.m_Weight = &weightsTensor;
2159 data.m_Bias = &biasTensor;
2160 data.m_Parameters.m_BiasEnabled = biasEnabled;
2161 data.m_Parameters.m_TransposeWeightMatrix = transposeWeights;
2162
2163 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateFullyConnected(data, info);
2164 LayerTestResult<T, 2> result(outputTensorInfo);
2165
2166 inputHandle->Allocate();
2167 outputHandle->Allocate();
2168 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2169
2170 ExecuteWorkload(*workload, memoryManager);
2171
2172 CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
2173
2174 return result;
2175}
2176
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2177template<armnn::DataType ArmnnType, typename T>
2178LayerTestResult<T, 2> FullyConnectedTest(
2179 armnn::IWorkloadFactory& workloadFactory,
2180 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2181 bool biasEnabled)
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2182{
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2183 constexpr static unsigned int inputWidth = 3u;
2184 constexpr static unsigned int inputHeight = 2u;
2185 constexpr static unsigned int inputChannels = 1u;
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2186
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2187 constexpr static unsigned int inputSize = inputWidth * inputHeight * inputChannels;
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2188
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2189 constexpr static unsigned int outputChannels = 2u;
2190
2191 armnn::TensorInfo inputTensorInfo({ 1, inputChannels, inputHeight, inputWidth }, ArmnnType);
2192 inputTensorInfo.SetQuantizationScale(0.1f);
2193 inputTensorInfo.SetQuantizationOffset(63);
2194
2195 armnn::TensorInfo outputTensorInfo({ 1, outputChannels }, ArmnnType);
2196 outputTensorInfo.SetQuantizationScale(5.f);
2197 outputTensorInfo.SetQuantizationOffset(biasEnabled ? -50 : 10);
2198
2199 armnn::TensorInfo weightsDesc({ outputChannels, inputSize }, ArmnnType);
2200 weightsDesc.SetQuantizationScale(0.2f);
2201 weightsDesc.SetQuantizationOffset(93);
2202
2203 armnn::TensorInfo biasesDesc({ outputChannels }, GetBiasTypeFromWeightsType(weightsDesc.GetDataType()).value());
2204 biasesDesc.SetQuantizationScale(inputTensorInfo.GetQuantizationScale() * weightsDesc.GetQuantizationScale());
2205 biasesDesc.SetQuantizationOffset(0);
2206
2207 LayerTestResult<T, 2> result(outputTensorInfo);
2208
2209 auto input = MakeTensor<T, 4>(inputTensorInfo, ConvertToDataType<ArmnnType>(
2210 {
2211 -1.2f, 6.1f, -3.5f,
2212 18.8f, -5.5f, 2.9f
2213 },
2214 inputTensorInfo));
2215
2216 auto weights = MakeTensor<T, 2>(weightsDesc, ConvertToDataType<ArmnnType>(
2217 {
2218 -8.4f, 20.0f, -10.4f, -8, 16.4f, -11.8f,
2219 23.4f, 10.4f, -14.0f, -3.8f, -11.8f, 11.4f
2220 },
2221 weightsDesc));
2222
2223 auto bias = MakeTensor<int32_t, 1>(biasesDesc, std::vector<int32_t>{9250, 67500});
2224
2225 result = SimpleFullyConnectedTestImpl<T>(
2226 workloadFactory,
2227 memoryManager,
2228 inputTensorInfo, outputTensorInfo,
2229 weightsDesc, biasesDesc,
2230 weights, bias, input,
2231 biasEnabled, true
2232 );
2233
2234 if (biasEnabled)
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2235 {
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2236 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo,
2237 ConvertToDataType<ArmnnType>({80.f, 1460.f}, outputTensorInfo));
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2238 }
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2239 else
2240 {
2241 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo,
2242 ConvertToDataType<ArmnnType>({-107.04f, 110.f}, outputTensorInfo));
2243 }
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2244
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2245 return result;
David Monahan34757812019-06-19 11:47:21 +0100[diff] [blame]2246}
2247
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2248template<armnn::DataType ArmnnType, typename T>
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2249LayerTestResult<T, 2> Rsqrt2dTestCommon(
2250 armnn::IWorkloadFactory& workloadFactory,
2251 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2252 const armnn::TensorInfo inputTensorInfo,
2253 const armnn::TensorInfo outputTensorInfo,
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2254 const std::vector<float>& inputValues,
2255 const std::vector<float>& expectedOutputValues)
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2256{
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2257 auto inputTensor = MakeTensor<T, 2>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputValues,inputTensorInfo));
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2258
2259 LayerTestResult<T, 2> result(outputTensorInfo);
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2260
2261 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo,
2262 ConvertToDataType<ArmnnType>(expectedOutputValues,outputTensorInfo));
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2263
2264 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2265 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2266
2267 armnn::RsqrtQueueDescriptor descriptor;
2268
2269 armnn::WorkloadInfo info;
2270
2271 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2272 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2273
2274 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateRsqrt(descriptor, info);
2275
2276 inputHandle->Allocate();
2277 outputHandle->Allocate();
2278
2279 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
2280
2281 workload->PostAllocationConfigure();
2282 workload->Execute();
2283
2284 CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
2285
2286 return result;
2287}
2288
2289template<armnn::DataType ArmnnType, typename T>
2290LayerTestResult<T, 2> Rsqrt2dTest(
2291 armnn::IWorkloadFactory& workloadFactory,
2292 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2293{
2294 const armnn::TensorShape inputShape{ 2, 2 };
2295 const armnn::TensorShape outputShape{ 2, 2 };
2296
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2297 armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2298 inputTensorInfo.SetQuantizationScale(0.1f);
2299 inputTensorInfo.SetQuantizationOffset(0);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2300
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2301 armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2302 outputTensorInfo.SetQuantizationScale(0.1f);
2303 outputTensorInfo.SetQuantizationOffset(0);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2304
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2305 std::vector<float> inputValues
2306 {
2307 1.f, 4.f,
2308 16.f, 25.f
2309 };
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2310
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2311 std::vector<float> expectedOutputValues
2312 {
2313 1.f, 0.5f,
2314 0.25f, 0.2f
2315 };
2316
2317 return Rsqrt2dTestCommon<ArmnnType>(workloadFactory, memoryManager,
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2318 inputTensorInfo, outputTensorInfo,
2319 inputValues, expectedOutputValues);
2320}
2321
2322template<armnn::DataType ArmnnType, typename T>
2323LayerTestResult<T, 3> Rsqrt3dTest(
2324 armnn::IWorkloadFactory& workloadFactory,
2325 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2326{
2327 const armnn::TensorShape inputShape{ 3, 1, 2 };
2328 const armnn::TensorShape outputShape{ 3, 1, 2 };
2329
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2330 armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2331 inputTensorInfo.SetQuantizationScale(0.1f);
2332 inputTensorInfo.SetQuantizationOffset(0);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2333
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2334 armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2335 outputTensorInfo.SetQuantizationScale(0.1f);
2336 outputTensorInfo.SetQuantizationOffset(0);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2337
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2338 std::vector<float> inputValues
2339 {
2340 1.f, 4.f, 16.f,
2341 25.f, 64.f, 100.f
2342 };
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2343
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2344 std::vector<float> expectedOutputValues
2345 {
2346 1.f, 0.5f, 0.25f,
2347 0.2f, 0.125f, 0.1f
2348 };
2349
2350 auto inputTensor = MakeTensor<T, 3>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputValues,inputTensorInfo));
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2351
2352 LayerTestResult<T, 3> result(outputTensorInfo);
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2353 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo,
2354 ConvertToDataType<ArmnnType>(expectedOutputValues,outputTensorInfo));
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2355
2356 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2357 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2358
2359 armnn::RsqrtQueueDescriptor descriptor;
2360
2361 armnn::WorkloadInfo info;
2362
2363 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2364 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2365
2366 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateRsqrt(descriptor, info);
2367
2368 inputHandle->Allocate();
2369 outputHandle->Allocate();
2370
2371 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0][0]);
2372
2373 workload->PostAllocationConfigure();
2374 workload->Execute();
2375
2376 CopyDataFromITensorHandle(&result.output[0][0][0], outputHandle.get());
2377
2378 return result;
2379}
2380
2381template<armnn::DataType ArmnnType, typename T>
2382LayerTestResult<T, 2> RsqrtZeroTest(
2383 armnn::IWorkloadFactory& workloadFactory,
2384 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2385{
2386 const armnn::TensorShape inputShape{ 1, 2 };
2387 const armnn::TensorShape outputShape{ 1, 2 };
2388
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2389 armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2390 inputTensorInfo.SetQuantizationScale(0.1f);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2391
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2392 armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2393 outputTensorInfo.SetQuantizationScale(0.1f);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2394
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2395 std::vector<float> inputValues
2396 {
2397 0.f, -0.f
2398 };
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2399
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2400 std::vector<float> expectedOutputValues
2401 {
2402 INFINITY, -INFINITY
2403 };
2404
2405 return Rsqrt2dTestCommon<ArmnnType>(workloadFactory, memoryManager,
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2406 inputTensorInfo, outputTensorInfo,
2407 inputValues, expectedOutputValues);
2408}
2409
2410template<armnn::DataType ArmnnType, typename T>
2411LayerTestResult<T, 2> RsqrtNegativeTest(
2412 armnn::IWorkloadFactory& workloadFactory,
2413 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2414{
2415 const armnn::TensorShape inputShape{ 1, 2 };
2416 const armnn::TensorShape outputShape{ 1, 2 };
2417
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2418 armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2419 inputTensorInfo.SetQuantizationScale(0.1f);
2420 inputTensorInfo.SetQuantizationOffset(0);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2421
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2422 armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2423 outputTensorInfo.SetQuantizationScale(0.1f);
2424 outputTensorInfo.SetQuantizationOffset(0);
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2425
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2426 std::vector<float> inputValues
2427 {
2428 -25.f, -16.f
2429 };
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2430
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]2431 std::vector<float> expectedOutputValues
2432 {
2433 -NAN, -NAN
2434 };
2435
2436 return Rsqrt2dTestCommon<ArmnnType>(workloadFactory, memoryManager,
nikraj0193f84a92019-06-05 10:48:46 +0100[diff] [blame]2437 inputTensorInfo, outputTensorInfo,
2438 inputValues, expectedOutputValues);
2439}
2440
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2441template<typename T, size_t NumDims>
2442LayerTestResult<T, NumDims> SimpleReshapeTestImpl(
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2443 armnn::IWorkloadFactory& workloadFactory,
2444 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2445 armnn::TensorInfo inputTensorInfo,
2446 armnn::TensorInfo outputTensorInfo,
2447 const std::vector<T>& inputData,
2448 const std::vector<T>& outputExpectedData)
2449{
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2450 auto input = MakeTensor<T, NumDims>(inputTensorInfo, inputData);
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2451
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2452 LayerTestResult<T, NumDims> ret(outputTensorInfo);
2453 ret.outputExpected = MakeTensor<T, NumDims>(outputTensorInfo, outputExpectedData);
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2454
2455 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2456 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2457
2458 armnn::ReshapeQueueDescriptor data;
2459 armnn::WorkloadInfo info;
2460 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
2461 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2462
2463 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateReshape(data, info);
2464
2465 inputHandle->Allocate();
2466 outputHandle->Allocate();
2467
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2468 CopyDataToITensorHandle(inputHandle.get(), input.origin());
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2469
2470 workload->Execute();
2471
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2472 CopyDataFromITensorHandle(ret.output.origin(), outputHandle.get());
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2473
2474 return ret;
2475}
2476
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]2477template<armnn::DataType ArmnnType, typename T>
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2478LayerTestResult<T, 4> SimpleReshapeTest(
2479 armnn::IWorkloadFactory& workloadFactory,
2480 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2481{
2482 armnn::TensorInfo inputTensorInfo;
2483 armnn::TensorInfo outputTensorInfo;
2484
2485 unsigned int inputShape[] = { 2, 2, 3, 3 };
2486 unsigned int outputShape[] = { 2, 2, 9, 1 };
2487
2488 inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
2489 inputTensorInfo.SetQuantizationScale(1.0f);
2490 outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
2491 outputTensorInfo.SetQuantizationScale(1.0f);
2492
2493 auto input = ConvertToDataType<ArmnnType>(
2494 {
2495 0.0f, 1.0f, 2.0f,
2496 3.0f, 4.0f, 5.0f,
2497 6.0f, 7.0f, 8.0f,
2498
2499 9.0f, 10.0f, 11.0f,
2500 12.0f, 13.0f, 14.0f,
2501 15.0f, 16.0f, 17.0f,
2502
2503 18.0f, 19.0f, 20.0f,
2504 21.0f, 22.0f, 23.0f,
2505 24.0f, 25.0f, 26.0f,
2506
2507 27.0f, 28.0f, 29.0f,
2508 30.0f, 31.0f, 32.0f,
2509 33.0f, 34.0f, 35.0f,
2510 },
2511 inputTensorInfo);
2512
2513 auto outputExpected = ConvertToDataType<ArmnnType>(
2514 {
2515 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
2516
2517 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
2518
2519 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f,
2520
2521 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f, 33.0f, 34.0f, 35.0f,
2522 },
2523 outputTensorInfo);
2524
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]2525 return SimpleReshapeTestImpl<T, 4>(
2526 workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
2527}
2528
2529template<armnn::DataType ArmnnType, typename T>
2530LayerTestResult<T, 5> Reshape5dTest(
2531 armnn::IWorkloadFactory& workloadFactory,
2532 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2533{
2534 armnn::TensorInfo inputTensorInfo;
2535 armnn::TensorInfo outputTensorInfo;
2536
2537 unsigned int inputShape[] = { 2, 2, 8, 1, 1 };
2538 unsigned int outputShape[] = { 2, 2, 2, 2, 2 };
2539
2540 inputTensorInfo = armnn::TensorInfo(5, inputShape, ArmnnType);
2541 inputTensorInfo.SetQuantizationScale(1.0f);
2542 outputTensorInfo = armnn::TensorInfo(5, outputShape, ArmnnType);
2543 outputTensorInfo.SetQuantizationScale(1.0f);
2544
2545 auto input = ConvertToDataType<ArmnnType>(
2546 {
2547 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f,
2548 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f,
2549
2550 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f,
2551 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f,
2552 },
2553 inputTensorInfo);
2554
2555 auto outputExpected = ConvertToDataType<ArmnnType>(
2556 {
2557 0.0f, 1.0f,
2558 2.0f, 3.0f,
2559
2560 4.0f, 5.0f,
2561 6.0f, 7.0f,
2562
2563
2564 8.0f, 9.0f,
2565 10.0f, 11.0f,
2566
2567 12.0f, 13.0f,
2568 14.0f, 15.0f,
2569
2570
2571
2572 16.0f, 17.0f,
2573 18.0f, 19.0f,
2574
2575 20.0f, 21.0f,
2576 22.0f, 23.0f,
2577
2578
2579 24.0f, 25.0f,
2580 26.0f, 27.0f,
2581
2582 28.0f, 29.0f,
2583 30.0f, 31.0f,
2584 },
2585 outputTensorInfo);
2586
2587 return SimpleReshapeTestImpl<T, 5>(
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]2588 workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
Matteo Martincigh42666a12019-05-29 08:53:41 +0100[diff] [blame]2589}
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]2590
2591template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2592LayerTestResult<T, 4> SimpleFloorTest(
2593 armnn::IWorkloadFactory& workloadFactory,
2594 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2595{
James Conroyb40d7102019-06-04 12:32:09 +0100[diff] [blame]2596 armnn::TensorInfo inputTensorInfo({1, 3, 2, 3}, ArmnnType);
2597 inputTensorInfo.SetQuantizationScale(0.1f);
2598
2599 armnn::TensorInfo outputTensorInfo(inputTensorInfo);
2600 outputTensorInfo.SetQuantizationScale(0.1f);
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]2601
2602 auto input = MakeTensor<T, 4>(inputTensorInfo, ConvertToDataType<ArmnnType>(
2603 { -37.5f, -15.2f, -8.76f, -2.0f, -1.5f, -1.3f, -0.5f, -0.4f, 0.0f,
2604 1.0f, 0.4f, 0.5f, 1.3f, 1.5f, 2.0f, 8.76f, 15.2f, 37.5f },
2605 inputTensorInfo));
2606
2607 LayerTestResult<T, 4> ret(outputTensorInfo);
2608 ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, ConvertToDataType<ArmnnType>(
2609 { -38.0f, -16.0f, -9.0f, -2.0f, -2.0f, -2.0f, -1.0f, -1.0f, 0.0f,
2610 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 8.0f, 15.0f, 37.0f },
2611 outputTensorInfo));
2612
2613 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2614 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2615
2616 armnn::FloorQueueDescriptor data;
2617 armnn::WorkloadInfo info;
2618 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
2619 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2620
2621 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateFloor(data, info);
2622
2623 inputHandle->Allocate();
2624 outputHandle->Allocate();
2625
2626 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2627
2628 workload->Execute();
2629
2630 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2631
2632 return ret;
Matteo Martincighf5507132019-06-04 10:59:47 +0100[diff] [blame]2633}
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2634
2635
2636template<armnn::DataType ArmnnType, typename T>
2637LayerTestResult<T, 4> ResizeBilinearNopTest(
2638 armnn::IWorkloadFactory& workloadFactory,
2639 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2640 const armnn::DataLayout dataLayout)
2641{
2642 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2643 ? armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
2644 : armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
2645 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2646 ? armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
2647 : armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
2648 if (armnn::IsQuantizedType<T>())
2649 {
2650 inputTensorInfo.SetQuantizationScale(1.5f);
2651 inputTensorInfo.SetQuantizationOffset(-3);
2652 outputTensorInfo.SetQuantizationScale(1.5f);
2653 outputTensorInfo.SetQuantizationOffset(-3);
2654 }
2655
2656 std::vector<float> inputData = armnn::IsQuantizedType<T>()
2657 ? std::initializer_list<float>
2658 {
2659 1, 2, 3, 4,
2660 2, 3, 4, 5,
2661 3, 4, 5, 6,
2662 4, 5, 6, 7
2663 }
2664 : std::initializer_list<float>
2665 {
2666 1.0f, 2.0f, 3.0f, 4.0f,
2667 2.0f, 3.0f, 4.0f, 5.0f,
2668 3.0f, 4.0f, 5.0f, 6.0f,
2669 4.0f, 5.0f, 6.0f, 7.0f,
2670
2671 1.0f, 2.0f, 3.0f, 4.0f,
2672 2.0f, 3.0f, 4.0f, 5.0f,
2673 3.0f, 4.0f, 5.0f, 6.0f,
2674 4.0f, 5.0f, 6.0f, 7.0f
2675 };
2676
2677 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2678 if (dataLayout == armnn::DataLayout::NHWC)
2679 {
2680 std::vector<float> tmp(inputData.size());
2681 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2682 inputData = tmp;
2683 }
2684
2685 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2686 inputTensorInfo.GetQuantizationOffset(),
2687 inputData));
2688
2689 LayerTestResult<T, 4> result(outputTensorInfo);
2690 result.outputExpected = input;
2691
2692 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2693 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2694
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2695 armnn::ResizeQueueDescriptor descriptor;
2696 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::Bilinear;
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2697 descriptor.m_Parameters.m_DataLayout = dataLayout;
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2698
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2699 armnn::WorkloadInfo info;
2700 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2701 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2702
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2703 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2704
2705 inputHandle->Allocate();
2706 outputHandle->Allocate();
2707 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2708
2709 workload->PostAllocationConfigure();
2710 workload->Execute();
2711
2712 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2713 return result;
2714}
2715
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2716template<armnn::DataType ArmnnType, typename T>
2717LayerTestResult<T, 4> SimpleResizeBilinearTest(
2718 armnn::IWorkloadFactory& workloadFactory,
2719 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2720 const armnn::DataLayout dataLayout)
2721{
2722 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2723 ? armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
2724 : armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
2725 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2726 ? armnnUtils::GetTensorInfo(1, 1, 1, 1, dataLayout, ArmnnType)
2727 : armnnUtils::GetTensorInfo(1, 2, 1, 1, dataLayout, ArmnnType);
2728
2729 if (armnn::IsQuantizedType<T>())
2730 {
2731 inputTensorInfo.SetQuantizationScale(0.1567f);
2732 inputTensorInfo.SetQuantizationOffset(1);
2733 outputTensorInfo.SetQuantizationScale(0.1567f);
2734 outputTensorInfo.SetQuantizationOffset(1);
2735 }
2736
2737 std::vector<float> inputData = armnn::IsQuantizedType<T>()
2738 ? std::initializer_list<float>
2739 {
2740 1, 255,
2741 200, 250
2742 }
2743 : std::initializer_list<float>
2744 {
2745 1.0f, 255.0f,
2746 200.0f, 250.0f,
2747
2748 250.0f, 200.0f,
2749 250.0f, 1.0f
2750 };
2751
2752 // The 'resize bilinear' operation projects the top-left corner of output texels into the input image,
2753 // then figures out the interpolants and weights. Note this is different to projecting the centre of the
2754 // output texel. Thus, for a input matrix of 2x2, we'll expect the output 1x1 matrix to contain, as
2755 // its single element, the value that was at position (0,0) of the input matrix (rather than an average,
2756 // which we would expect if projecting the centre).
2757
2758 std::vector<float> outputData = armnn::IsQuantizedType<T>()
2759 ? std::initializer_list<float>
2760 {
2761 1
2762 }
2763 : std::initializer_list<float>
2764 {
2765 1.0f,
2766
2767 250.0f
2768 };
2769
2770 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2771 if (dataLayout == armnn::DataLayout::NHWC)
2772 {
2773 std::vector<float> tmp(inputData.size());
2774 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2775 inputData = tmp;
2776
2777 std::vector<float> tmp1(outputData.size());
2778 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2779 outputData = tmp1;
2780 }
2781
2782 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2783 inputTensorInfo.GetQuantizationOffset(),
2784 inputData));
2785
2786 LayerTestResult<T, 4> result(outputTensorInfo);
2787 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2788 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2789 outputTensorInfo.GetQuantizationOffset(),
2790 outputData));
2791
2792 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2793 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2794
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2795 armnn::ResizeQueueDescriptor descriptor;
2796 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::Bilinear;
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2797 descriptor.m_Parameters.m_DataLayout = dataLayout;
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2798
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2799 armnn::WorkloadInfo info;
2800 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2801 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2802
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2803 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2804
2805 inputHandle->Allocate();
2806 outputHandle->Allocate();
2807 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2808
2809 workload->PostAllocationConfigure();
2810 workload->Execute();
2811
2812 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2813 return result;
2814}
2815
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2816template<armnn::DataType ArmnnType, typename T>
2817LayerTestResult<T, 4> ResizeBilinearSqMinTest(
2818 armnn::IWorkloadFactory& workloadFactory,
2819 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2820 const armnn::DataLayout dataLayout)
2821{
2822 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2823 ? armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
2824 : armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
2825 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2826 ? armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
2827 : armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
2828
2829 if (armnn::IsQuantizedType<T>())
2830 {
2831 inputTensorInfo.SetQuantizationScale(3.141592f);
2832 inputTensorInfo.SetQuantizationOffset(3);
2833 outputTensorInfo.SetQuantizationScale(3.141592f);
2834 outputTensorInfo.SetQuantizationOffset(3);
2835 }
2836
2837 std::vector<float> inputData = armnn::IsQuantizedType<T>()
2838 ? std::initializer_list<float>
2839 {
2840 1, 2, 3, 4,
2841 2, 3, 4, 5,
2842 3, 4, 5, 6,
2843 4, 5, 6, 7
2844 }
2845 : std::initializer_list<float>
2846 {
2847 1.0f, 2.0f, 3.0f, 4.0f,
2848 2.0f, 3.0f, 4.0f, 5.0f,
2849 3.0f, 4.0f, 5.0f, 6.0f,
2850 4.0f, 5.0f, 6.0f, 7.0f,
2851
2852 7.0f, 6.0f, 5.0f, 4.0f,
2853 6.0f, 5.0f, 4.0f, 3.0f,
2854 5.0f, 4.0f, 3.0f, 2.0f,
2855 4.0f, 3.0f, 2.0f, 1.0f
2856 };
2857
2858 std::vector<float> outputData = armnn::IsQuantizedType<T>()
2859 ? std::initializer_list<float>
2860 {
2861 1, 3,
2862 3, 5
2863 }
2864 : std::initializer_list<float>
2865 {
2866 1.0f, 3.0f,
2867 3.0f, 5.0f,
2868
2869 7.0f, 5.0f,
2870 5.0f, 3.0f
2871 };
2872
2873 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2874 if (dataLayout == armnn::DataLayout::NHWC)
2875 {
2876 std::vector<float> tmp(inputData.size());
2877 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2878 inputData = tmp;
2879
2880 std::vector<float> tmp1(outputData.size());
2881 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2882 outputData = tmp1;
2883 }
2884
2885 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2886 inputTensorInfo.GetQuantizationOffset(),
2887 inputData));
2888
2889 LayerTestResult<T, 4> result(outputTensorInfo);
2890 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2891 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2892 outputTensorInfo.GetQuantizationOffset(),
2893 outputData));
2894
2895 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2896 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2897
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2898 armnn::ResizeQueueDescriptor descriptor;
2899 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::Bilinear;
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2900 descriptor.m_Parameters.m_DataLayout = dataLayout;
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2901
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2902 armnn::WorkloadInfo info;
2903 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2904 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2905
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2906 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2907
2908 inputHandle->Allocate();
2909 outputHandle->Allocate();
2910 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2911
2912 workload->PostAllocationConfigure();
2913 workload->Execute();
2914
2915 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2916 return result;
2917}
2918
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2919template<armnn::DataType ArmnnType, typename T>
2920LayerTestResult<T, 4> ResizeBilinearMinTest(
2921 armnn::IWorkloadFactory& workloadFactory,
2922 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2923 const armnn::DataLayout dataLayout)
2924{
2925 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2926 ? armnnUtils::GetTensorInfo(1, 1, 2, 3, dataLayout, ArmnnType)
2927 : armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
2928 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2929 ? armnnUtils::GetTensorInfo(1, 1, 1, 2, dataLayout, ArmnnType)
2930 : armnnUtils::GetTensorInfo(1, 2, 2, 3, dataLayout, ArmnnType);
2931
2932 if (armnn::IsQuantizedType<T>())
2933 {
2934 inputTensorInfo.SetQuantizationScale(1.5f);
2935 inputTensorInfo.SetQuantizationOffset(-1);
2936 outputTensorInfo.SetQuantizationScale(1.5f);
2937 outputTensorInfo.SetQuantizationOffset(-1);
2938 }
2939
2940 std::vector<float> inputData = armnn::IsQuantizedType<T>()
2941 ? std::initializer_list<float>
2942 {
2943 3.0f, 4.5f, 6.0f, // 1, 2, 3, : Expected quantised values
2944 9.0f, 13.5f, 21.0f // 5, 8, 13
2945 }
2946 : std::initializer_list<float>
2947 {
2948 1.0f, 2.0f, 3.0f, 5.0f, 8.0f,
2949 13.0f, 21.0f, 34.0f, 55.0f, 89.0f,
2950 144.0f, 233.0f, 377.0f, 610.0f, 987.0f,
2951
2952 987.0f, 610.0f, 377.0f, 233.0f, 144.0f,
2953 89.0f, 55.0f, 34.0f, 21.0f, 13.0f,
2954 8.0f, 5.0f, 3.0f, 2.0f, 1.0f
2955 };
2956
2957 std::vector<float> outputData = armnn::IsQuantizedType<T>()
2958 ? std::initializer_list<float>
2959 {
2960 3.0f, 5.25f // 1, 3
2961 }
2962 : std::initializer_list<float>
2963 {
2964 1.0f, 2.6666f, 6.00f,
2965 78.5f, 179.3333f, 401.00f,
2966
2967 987.0f, 454.6670f, 203.33f,
2968 48.5f, 22.3333f, 10.00f
2969 };
2970
2971 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2972 if (dataLayout == armnn::DataLayout::NHWC)
2973 {
2974 std::vector<float> tmp(inputData.size());
2975 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2976 inputData = tmp;
2977
2978 std::vector<float> tmp1(outputData.size());
2979 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2980 outputData = tmp1;
2981 }
2982
2983 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2984 inputTensorInfo.GetQuantizationOffset(),
2985 inputData));
2986
2987 LayerTestResult<T, 4> result(outputTensorInfo);
2988 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2989 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2990 outputTensorInfo.GetQuantizationOffset(),
2991 outputData));
2992
2993 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2994 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2995
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2996 armnn::ResizeQueueDescriptor descriptor;
2997 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::Bilinear;
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]2998 descriptor.m_Parameters.m_DataLayout = dataLayout;
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]2999
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]3000 armnn::WorkloadInfo info;
3001 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3002 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3003
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]3004 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]3005
3006 inputHandle->Allocate();
3007 outputHandle->Allocate();
3008 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3009
3010 workload->PostAllocationConfigure();
3011 workload->Execute();
3012
3013 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3014 return result;
3015}
3016
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]3017template<armnn::DataType ArmnnType, typename T>
3018LayerTestResult<T, 4> ResizeBilinearMagTest(
3019 armnn::IWorkloadFactory& workloadFactory,
3020 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3021 const armnn::DataLayout dataLayout)
3022{
3023 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3024 ? armnnUtils::GetTensorInfo(1, 1, 3, 2, dataLayout, ArmnnType)
3025 : armnnUtils::GetTensorInfo(1, 2, 3, 2, dataLayout, ArmnnType);
3026 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3027 ? armnnUtils::GetTensorInfo(1, 1, 3, 5, dataLayout, ArmnnType)
3028 : armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
3029
3030 if (armnn::IsQuantizedType<T>())
3031 {
3032 inputTensorInfo.SetQuantizationScale(0.010765f);
3033 inputTensorInfo.SetQuantizationOffset(7);
3034 outputTensorInfo.SetQuantizationScale(0.010132f);
3035 outputTensorInfo.SetQuantizationOffset(-18);
3036 }
3037
3038 std::vector<float> inputData = armnn::IsQuantizedType<T>()
3039 ? std::initializer_list<float>
3040 {
3041 0.183005f, 2.379065f, // 24, 228, : Expected quantised values
3042 1.05497f, 1.302565f, // 105, 128,
3043 2.400595f, 0.68896f // 230, 71
3044 }
3045 : std::initializer_list<float>
3046 {
3047 1.0f, 2.0f,
3048 13.0f, 21.0f,
3049 144.0f, 233.0f,
3050
3051 233.0f, 144.0f,
3052 21.0f, 13.0f,
3053 2.0f, 1.0f
3054 };
3055 std::vector<float> outputData = armnn::IsQuantizedType<T>()
3056 ? std::initializer_list<float>
3057 {
3058 0.18300501f, 1.06142902f, 1.93985295f, 2.37906504f, 2.37906504f,
3059 1.05497003f, 1.15400803f, 1.25304604f, 1.30256498f, 1.30256498f,
3060 2.40059495f, 1.71594095f, 1.03128707f, 0.68896002f, 0.68896002f
3061 // 0, 87, 173, 217, 217, : Expected quantised values
3062 // 86, 96, 106, 111, 111,
3063 // 219, 151, 84, 50, 50
3064 }
3065 : std::initializer_list<float>
3066 {
3067 1.0f, 1.4f, 1.8f, 2.0f, 2.0f,
3068 13.0f, 16.2f, 19.4f, 21.0f, 21.0f,
3069 144.0f, 179.6f, 215.2f, 233.0f, 233.0f,
3070
3071 233.0f, 197.4f, 161.8f, 144.0f, 144.0f,
3072 21.0f, 17.8f, 14.6f, 13.0f, 13.0f,
3073 2.0f, 1.6f, 1.2f, 1.0f, 1.0f
3074 };
3075
3076 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3077 if (dataLayout == armnn::DataLayout::NHWC)
3078 {
3079 std::vector<float> tmp(inputData.size());
3080 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3081 inputData = tmp;
3082
3083 std::vector<float> tmp1(outputData.size());
3084 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3085 outputData = tmp1;
3086 }
3087
3088 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3089 inputTensorInfo.GetQuantizationOffset(),
3090 inputData));
3091
3092 LayerTestResult<T, 4> result(outputTensorInfo);
3093 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3094 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3095 outputTensorInfo.GetQuantizationOffset(),
3096 outputData));
3097
3098 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3099 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3100
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]3101 armnn::ResizeQueueDescriptor descriptor;
3102 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::Bilinear;
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]3103 descriptor.m_Parameters.m_DataLayout = dataLayout;
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]3104
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]3105 armnn::WorkloadInfo info;
3106 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3107 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3108
Aron Virginas-Tar169d2f12019-07-01 19:01:44 +0100[diff] [blame]3109 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
Ellen Norris-Thompsonc4223d12019-06-10 14:15:12 +0100[diff] [blame]3110
3111 inputHandle->Allocate();
3112 outputHandle->Allocate();
3113 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3114
3115 workload->PostAllocationConfigure();
3116 workload->Execute();
3117
3118 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3119 return result;
3120}
3121
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3122
3123template<armnn::DataType ArmnnType, typename T>
3124LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
3125 armnn::IWorkloadFactory& workloadFactory,
3126 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3127 const armnn::DataLayout dataLayout)
3128{
3129 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3130 ? armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
3131 : armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
3132 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3133 ? armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
3134 : armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
3135 if (armnn::IsQuantizedType<T>())
3136 {
3137 inputTensorInfo.SetQuantizationScale(1.5f);
3138 inputTensorInfo.SetQuantizationOffset(-3);
3139 outputTensorInfo.SetQuantizationScale(1.5f);
3140 outputTensorInfo.SetQuantizationOffset(-3);
3141 }
3142
3143 std::vector<float> inputData = armnn::IsQuantizedType<T>()
3144 ? std::initializer_list<float>
3145 {
3146 1, 2, 3, 4,
3147 2, 3, 4, 5,
3148 3, 4, 5, 6,
3149 4, 5, 6, 7
3150 }
3151 : std::initializer_list<float>
3152 {
3153 1.0f, 2.0f, 3.0f, 4.0f,
3154 2.0f, 3.0f, 4.0f, 5.0f,
3155 3.0f, 4.0f, 5.0f, 6.0f,
3156 4.0f, 5.0f, 6.0f, 7.0f,
3157
3158 1.0f, 2.0f, 3.0f, 4.0f,
3159 2.0f, 3.0f, 4.0f, 5.0f,
3160 3.0f, 4.0f, 5.0f, 6.0f,
3161 4.0f, 5.0f, 6.0f, 7.0f
3162 };
3163
3164 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3165 if (dataLayout == armnn::DataLayout::NHWC)
3166 {
3167 std::vector<float> tmp(inputData.size());
3168 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3169 inputData = tmp;
3170 }
3171
3172 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3173 inputTensorInfo.GetQuantizationOffset(),
3174 inputData));
3175
3176 LayerTestResult<T, 4> result(outputTensorInfo);
3177 result.outputExpected = input;
3178
3179 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3180 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3181
3182 armnn::ResizeQueueDescriptor descriptor;
3183 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3184 descriptor.m_Parameters.m_DataLayout = dataLayout;
3185 armnn::WorkloadInfo info;
3186 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3187 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3188
3189 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3190
3191 inputHandle->Allocate();
3192 outputHandle->Allocate();
3193 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3194
3195 workload->PostAllocationConfigure();
3196 workload->Execute();
3197
3198 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3199 return result;
3200}
3201
3202template<armnn::DataType ArmnnType, typename T>
3203LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
3204 armnn::IWorkloadFactory& workloadFactory,
3205 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3206 const armnn::DataLayout dataLayout)
3207{
3208 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3209 ? armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
3210 : armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
3211 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3212 ? armnnUtils::GetTensorInfo(1, 1, 1, 1, dataLayout, ArmnnType)
3213 : armnnUtils::GetTensorInfo(1, 2, 1, 1, dataLayout, ArmnnType);
3214
3215 if (armnn::IsQuantizedType<T>())
3216 {
3217 inputTensorInfo.SetQuantizationScale(0.1567f);
3218 inputTensorInfo.SetQuantizationOffset(1);
3219 outputTensorInfo.SetQuantizationScale(0.1567f);
3220 outputTensorInfo.SetQuantizationOffset(1);
3221 }
3222
3223 std::vector<float> inputData = armnn::IsQuantizedType<T>()
3224 ? std::initializer_list<float>
3225 {
3226 1, 255,
3227 200, 250
3228 }
3229 : std::initializer_list<float>
3230 {
3231 1.0f, 255.0f,
3232 200.0f, 250.0f,
3233
3234 250.0f, 200.0f,
3235 250.0f, 1.0f
3236 };
3237
3238 // The 'resize' operation projects the top-left corner of output texels into the input image,
3239 // then figures out the interpolants and weights. Note this is different to projecting the centre of the
3240 // output texel. Thus, for a input matrix of 2x2, we'll expect the output 1x1 matrix to contain, as
3241 // its single element, the value that was at position (0,0) of the input matrix (rather than an average,
3242 // which we would expect if projecting the centre).
3243
3244 std::vector<float> outputData = armnn::IsQuantizedType<T>()
3245 ? std::initializer_list<float>
3246 {
3247 1
3248 }
3249 : std::initializer_list<float>
3250 {
3251 1.0f,
3252
3253 250.0f
3254 };
3255
3256 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3257 if (dataLayout == armnn::DataLayout::NHWC)
3258 {
3259 std::vector<float> tmp(inputData.size());
3260 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3261 inputData = tmp;
3262
3263 std::vector<float> tmp1(outputData.size());
3264 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3265 outputData = tmp1;
3266 }
3267
3268 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3269 inputTensorInfo.GetQuantizationOffset(),
3270 inputData));
3271
3272 LayerTestResult<T, 4> result(outputTensorInfo);
3273 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3274 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3275 outputTensorInfo.GetQuantizationOffset(),
3276 outputData));
3277
3278 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3279 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3280
3281 armnn::ResizeQueueDescriptor descriptor;
3282 descriptor.m_Parameters.m_DataLayout = dataLayout;
3283 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3284 armnn::WorkloadInfo info;
3285 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3286 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3287
3288 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3289
3290 inputHandle->Allocate();
3291 outputHandle->Allocate();
3292 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3293
3294 workload->PostAllocationConfigure();
3295 workload->Execute();
3296
3297 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3298 return result;
3299}
3300
3301template<armnn::DataType ArmnnType, typename T>
3302LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
3303 armnn::IWorkloadFactory& workloadFactory,
3304 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3305 const armnn::DataLayout dataLayout)
3306{
3307 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3308 ? armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
3309 : armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
3310 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3311 ? armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
3312 : armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
3313
3314 if (armnn::IsQuantizedType<T>())
3315 {
3316 inputTensorInfo.SetQuantizationScale(3.141592f);
3317 inputTensorInfo.SetQuantizationOffset(3);
3318 outputTensorInfo.SetQuantizationScale(3.141592f);
3319 outputTensorInfo.SetQuantizationOffset(3);
3320 }
3321
3322 std::vector<float> inputData = armnn::IsQuantizedType<T>()
3323 ? std::initializer_list<float>
3324 {
3325 1, 2, 3, 4,
3326 2, 3, 4, 5,
3327 3, 4, 5, 6,
3328 4, 5, 6, 7
3329 }
3330 : std::initializer_list<float>
3331 {
3332 1.0f, 2.0f, 3.0f, 4.0f,
3333 2.0f, 3.0f, 4.0f, 5.0f,
3334 3.0f, 4.0f, 5.0f, 6.0f,
3335 4.0f, 5.0f, 6.0f, 7.0f,
3336
3337 7.0f, 6.0f, 5.0f, 4.0f,
3338 6.0f, 5.0f, 4.0f, 3.0f,
3339 5.0f, 4.0f, 3.0f, 2.0f,
3340 4.0f, 3.0f, 2.0f, 1.0f
3341 };
3342
3343 std::vector<float> outputData = armnn::IsQuantizedType<T>()
3344 ? std::initializer_list<float>
3345 {
3346 1, 3,
3347 3, 5
3348 }
3349 : std::initializer_list<float>
3350 {
3351 1.0f, 3.0f,
3352 3.0f, 5.0f,
3353
3354 7.0f, 5.0f,
3355 5.0f, 3.0f
3356 };
3357
3358 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3359 if (dataLayout == armnn::DataLayout::NHWC)
3360 {
3361 std::vector<float> tmp(inputData.size());
3362 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3363 inputData = tmp;
3364
3365 std::vector<float> tmp1(outputData.size());
3366 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3367 outputData = tmp1;
3368 }
3369
3370 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3371 inputTensorInfo.GetQuantizationOffset(),
3372 inputData));
3373
3374 LayerTestResult<T, 4> result(outputTensorInfo);
3375 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3376 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3377 outputTensorInfo.GetQuantizationOffset(),
3378 outputData));
3379
3380 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3381 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3382
3383 armnn::ResizeQueueDescriptor descriptor;
3384 descriptor.m_Parameters.m_DataLayout = dataLayout;
3385 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3386 armnn::WorkloadInfo info;
3387 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3388 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3389
3390 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3391
3392 inputHandle->Allocate();
3393 outputHandle->Allocate();
3394 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3395
3396 workload->PostAllocationConfigure();
3397 workload->Execute();
3398
3399 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3400 return result;
3401}
3402
3403template<armnn::DataType ArmnnType, typename T>
3404LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
3405 armnn::IWorkloadFactory& workloadFactory,
3406 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3407 const armnn::DataLayout dataLayout)
3408{
3409 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3410 ? armnnUtils::GetTensorInfo(1, 1, 2, 3, dataLayout, ArmnnType)
3411 : armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
3412 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3413 ? armnnUtils::GetTensorInfo(1, 1, 1, 2, dataLayout, ArmnnType)
3414 : armnnUtils::GetTensorInfo(1, 2, 2, 3, dataLayout, ArmnnType);
3415
3416 if (armnn::IsQuantizedType<T>())
3417 {
3418 inputTensorInfo.SetQuantizationScale(1.5f);
3419 inputTensorInfo.SetQuantizationOffset(-1);
3420 outputTensorInfo.SetQuantizationScale(1.5f);
3421 outputTensorInfo.SetQuantizationOffset(-1);
3422 }
3423
3424 std::vector<float> inputData = armnn::IsQuantizedType<T>()
3425 ? std::initializer_list<float>
3426 {
3427 3.0f, 4.5f, 6.0f, // 1, 2, 3, : Expected quantised values
3428 9.0f, 13.5f, 21.0f // 5, 8, 13
3429 }
3430 : std::initializer_list<float>
3431 {
3432 1.0f, 2.0f, 3.0f, 5.0f, 8.0f,
3433 13.0f, 21.0f, 34.0f, 55.0f, 89.0f,
3434 144.0f, 233.0f, 377.0f, 610.0f, 987.0f,
3435
3436 987.0f, 610.0f, 377.0f, 233.0f, 144.0f,
3437 89.0f, 55.0f, 34.0f, 21.0f, 13.0f,
3438 8.0f, 5.0f, 3.0f, 2.0f, 1.0f
3439 };
3440
3441 std::vector<float> outputData = armnn::IsQuantizedType<T>()
3442 ? std::initializer_list<float>
3443 {
3444 3.0f, 4.5f // 1, 3
3445 }
3446 : std::initializer_list<float>
3447 {
3448 1.f, 2.f, 5.f,
3449 13.f, 21.f, 55.f,
3450
3451 987.f, 610.f, 233.f,
3452 89.f, 55.f, 21.f
3453 };
3454
3455 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3456 if (dataLayout == armnn::DataLayout::NHWC)
3457 {
3458 std::vector<float> tmp(inputData.size());
3459 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3460 inputData = tmp;
3461
3462 std::vector<float> tmp1(outputData.size());
3463 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3464 outputData = tmp1;
3465 }
3466
3467 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3468 inputTensorInfo.GetQuantizationOffset(),
3469 inputData));
3470
3471 LayerTestResult<T, 4> result(outputTensorInfo);
3472 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3473 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3474 outputTensorInfo.GetQuantizationOffset(),
3475 outputData));
3476
3477 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3478 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3479
3480 armnn::ResizeQueueDescriptor descriptor;
3481 descriptor.m_Parameters.m_DataLayout = dataLayout;
3482 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3483 armnn::WorkloadInfo info;
3484 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3485 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3486
3487 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3488
3489 inputHandle->Allocate();
3490 outputHandle->Allocate();
3491 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3492
3493 workload->PostAllocationConfigure();
3494 workload->Execute();
3495
3496 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3497 return result;
3498}
3499
3500template<armnn::DataType ArmnnType, typename T>
3501LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
3502 armnn::IWorkloadFactory& workloadFactory,
3503 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3504 const armnn::DataLayout dataLayout,
3505 float inQuantScale,
3506 int32_t inQuantOffset,
3507 float outQuantScale,
3508 int32_t outQuantOffset)
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3509{
3510 armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3511 ? armnnUtils::GetTensorInfo(1, 1, 3, 2, dataLayout, ArmnnType)
3512 : armnnUtils::GetTensorInfo(1, 2, 3, 2, dataLayout, ArmnnType);
3513 armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3514 ? armnnUtils::GetTensorInfo(1, 1, 3, 5, dataLayout, ArmnnType)
3515 : armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
3516
3517 if (armnn::IsQuantizedType<T>())
3518 {
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3519 inputTensorInfo.SetQuantizationScale(inQuantScale);
3520 inputTensorInfo.SetQuantizationOffset(inQuantOffset);
3521 outputTensorInfo.SetQuantizationScale(outQuantScale);
3522 outputTensorInfo.SetQuantizationOffset(outQuantOffset);
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3523 }
3524
3525 std::vector<float> inputData = armnn::IsQuantizedType<T>()
3526 ? std::initializer_list<float>
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3527 {
3528 0.183005f, 2.379065f, // 24, 228, : expected quantised values
3529 1.054970f, 1.302565f, // 105, 128,
3530 2.400595f, 0.688960f // 230, 71
3531 }
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3532 : std::initializer_list<float>
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3533 {
3534 1.0f, 2.0f,
3535 13.0f, 21.0f,
3536 144.0f, 233.0f,
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3537
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3538 233.0f, 144.0f,
3539 21.0f, 13.0f,
3540 2.0f, 1.0f
3541 };
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3542 std::vector<float> outputData = armnn::IsQuantizedType<T>()
3543 ? std::initializer_list<float>
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3544 {
3545 0.183005f, 0.183005f, 0.183005f, 2.379065f, 2.379065f,
3546 1.054970f, 1.054970f, 1.054970f, 1.302565f, 1.302565f,
3547 2.400595f, 2.400595f, 2.400595f, 0.688960f, 0.688960f
3548 }
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3549 : std::initializer_list<float>
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3550 {
3551 1.f, 1.f, 1.f, 2.f, 2.f,
3552 13.f, 13.f, 13.f, 21.f, 21.f,
3553 144.f, 144.f, 144.f, 233.f, 233.f,
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3554
Aron Virginas-Tarcc0cefb2019-07-02 17:25:47 +0100[diff] [blame]3555 233.f, 233.f, 233.f, 144.f, 144.f,
3556 21.f, 21.f, 21.f, 13.f, 13.f,
3557 2.f, 2.f, 2.f, 1.f, 1.f
3558 };
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]3559
3560 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3561 if (dataLayout == armnn::DataLayout::NHWC)
3562 {
3563 std::vector<float> tmp(inputData.size());
3564 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3565 inputData = tmp;
3566
3567 std::vector<float> tmp1(outputData.size());
3568 armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3569 outputData = tmp1;
3570 }
3571
3572 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3573 inputTensorInfo.GetQuantizationOffset(),
3574 inputData));
3575
3576 LayerTestResult<T, 4> result(outputTensorInfo);
3577 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3578 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3579 outputTensorInfo.GetQuantizationOffset(),
3580 outputData));
3581
3582 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3583 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3584
3585 armnn::ResizeQueueDescriptor descriptor;
3586 descriptor.m_Parameters.m_DataLayout = dataLayout;
3587 descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3588 armnn::WorkloadInfo info;
3589 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3590 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3591
3592 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3593
3594 inputHandle->Allocate();
3595 outputHandle->Allocate();
3596 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3597
3598 workload->PostAllocationConfigure();
3599 workload->Execute();
3600
3601 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3602 return result;
3603}
3604
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]3605template<armnn::DataType ArmnnType, typename T, std::size_t InputDim, std::size_t OutputDim>
3606LayerTestResult<T, OutputDim> MeanTestHelper(
3607 armnn::IWorkloadFactory& workloadFactory,
3608 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3609 const unsigned int* inputShape,
3610 const std::vector<float>& inputData,
3611 const std::vector<unsigned int>& axis,
3612 bool keepDims,
3613 const unsigned int* outputShape,
3614 const std::vector<float>& outputData,
3615 float scale = 1.0f,
3616 int32_t offset = 0)
3617{
3618 armnn::TensorInfo inputTensorInfo(InputDim, inputShape, ArmnnType);
3619 armnn::TensorInfo outputTensorInfo(OutputDim, outputShape, ArmnnType);
3620
3621 inputTensorInfo.SetQuantizationScale(scale);
3622 inputTensorInfo.SetQuantizationOffset(offset);
3623
3624 outputTensorInfo.SetQuantizationScale(scale);
3625 outputTensorInfo.SetQuantizationOffset(offset);
3626
3627 auto input = MakeTensor<T, InputDim>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputData, inputTensorInfo));
3628
3629 LayerTestResult<T, OutputDim> result(outputTensorInfo);
3630 result.outputExpected = MakeTensor<T, OutputDim>(
3631 outputTensorInfo, ConvertToDataType<ArmnnType>(outputData, outputTensorInfo));
3632
3633 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3634 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3635
3636 armnn::MeanQueueDescriptor data;
3637 data.m_Parameters.m_Axis = axis;
3638 data.m_Parameters.m_KeepDims = keepDims;
3639 armnn::WorkloadInfo info;
3640 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
3641 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
3642
3643 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateMean(data, info);
3644
3645 inputHandle->Allocate();
3646 outputHandle->Allocate();
3647
3648 CopyDataToITensorHandle(inputHandle.get(), input.origin());
3649
3650 workload->PostAllocationConfigure();
3651 workload->Execute();
3652
3653 CopyDataFromITensorHandle(result.output.origin(), outputHandle.get());
3654
3655 return result;
3656}
3657
3658template<armnn::DataType ArmnnType, typename T>
3659LayerTestResult<T, 1> MeanSimpleTest(
3660 armnn::IWorkloadFactory& workloadFactory,
3661 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3662{
3663 const unsigned int inputShape[] = { 3, 2 };
3664 const unsigned int outputShape[] = { 1 };
3665
3666 std::vector<float> input({ 1.5f, 1.5f, 2.5f, 2.5f, 3.5f, 3.5f });
3667 std::vector<float> output({ 2.5f });
3668
3669 return MeanTestHelper<ArmnnType, T, 2, 1>(
3670 workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output);
3671}
3672
3673template<armnn::DataType ArmnnType, typename T>
3674LayerTestResult<T, 3> MeanSimpleAxisTest(
3675 armnn::IWorkloadFactory& workloadFactory,
3676 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3677{
3678 const unsigned int inputShape[] = { 2, 3, 1, 2 };
3679 const unsigned int outputShape[] = { 3, 1, 2 };
3680
3681 std::vector<float> input({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f });
3682 std::vector<float> output({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f });
3683
3684 return MeanTestHelper<ArmnnType, T, 4, 3>(
3685 workloadFactory, memoryManager, inputShape, input, { 0 }, false, outputShape, output);
3686}
3687
3688template<armnn::DataType ArmnnType, typename T>
3689LayerTestResult<T, 4> MeanKeepDimsTest(
3690 armnn::IWorkloadFactory& workloadFactory,
3691 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3692{
3693 const unsigned int inputShape[] = { 1, 1, 3, 2 };
3694 const unsigned int outputShape[] = { 1, 1, 1, 2 };
3695
3696 std::vector<float> input({ 1.5f, 1.5f, 2.5f, 2.5f, 3.5f, 3.5f });
3697 std::vector<float> output({ 2.5f, 2.5f });
3698
3699 return MeanTestHelper<ArmnnType, T, 4, 4>(
3700 workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output);
3701}
3702
3703template<armnn::DataType ArmnnType, typename T>
3704LayerTestResult<T, 4> MeanMultipleDimsTest(
3705 armnn::IWorkloadFactory& workloadFactory,
3706 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3707{
3708 const unsigned int inputShape[] = { 2, 3, 1, 2 };
3709 const unsigned int outputShape[] = { 1, 3, 1, 1 };
3710
3711 std::vector<float> input({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5 });
3712 std::vector<float> output({ 2.0f, 4.0f, 6.0f });
3713
3714 return MeanTestHelper<ArmnnType, T, 4, 4>(
3715 workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output);
3716}
3717
3718template<armnn::DataType ArmnnType, typename T>
3719LayerTestResult<T, 1> MeanVts1Test(
3720 armnn::IWorkloadFactory& workloadFactory,
3721 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3722{
3723 const unsigned int inputShape[] = { 4, 3, 2 };
3724 const unsigned int outputShape[] = { 2 };
3725
3726 std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f,
3727 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f });
3728 std::vector<float> output({ 12.0f, 13.0f });
3729
3730 return MeanTestHelper<ArmnnType, T, 3, 1>(
3731 workloadFactory, memoryManager, inputShape, input, { 0, 1 }, false, outputShape, output);
3732}
3733
3734template<armnn::DataType ArmnnType, typename T>
3735LayerTestResult<T, 3> MeanVts2Test(
3736 armnn::IWorkloadFactory& workloadFactory,
3737 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3738{
3739 const unsigned int inputShape[] = { 4, 3, 2 };
3740 const unsigned int outputShape[] = { 1, 3, 1 };
3741
3742 std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f,
3743 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f });
3744 std::vector<float> output({ 10.5f, 12.5f, 14.5f });
3745
3746 return MeanTestHelper<ArmnnType, T, 3, 3>(
3747 workloadFactory, memoryManager, inputShape, input, { 0, 2 }, true, outputShape, output);
3748}
3749
3750template<armnn::DataType ArmnnType, typename T>
3751LayerTestResult<T, 3> MeanVts3Test(
3752 armnn::IWorkloadFactory& workloadFactory,
3753 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3754{
3755 const unsigned int inputShape[] = { 1, 2, 2, 1 };
3756 const unsigned int outputShape[] = { 1, 2, 1 };
3757
3758 std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f });
3759 std::vector<float> output({ 1.5f, 3.5f });
3760
3761 return MeanTestHelper<ArmnnType, T, 4, 3>(
3762 workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output);
3763}
Narumol Prangnawarat71c80b12019-06-17 17:45:43 +0100[diff] [blame]3764
3765template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
3766LayerTestResult<T, 3> ConcatDifferentInputOutputQParamTest(
3767 armnn::IWorkloadFactory& workloadFactory,
3768 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3769 bool useSubtensor)
3770{
3771 // Defines the tensor descriptors.
3772 armnn::TensorInfo outputTensorInfo({ 3, 6, 3 }, ArmnnType);
3773 armnn::TensorInfo inputTensorInfo1({ 3, 6, 2 }, ArmnnType);
3774 armnn::TensorInfo inputTensorInfo2({ 3, 6, 1 }, ArmnnType);
3775
3776 std::vector<armnn::TensorShape> inputTensorShapes({inputTensorInfo1.GetShape(), inputTensorInfo2.GetShape()});
3777
3778 // Quantized input1 tensor.
3779 const float inputScale1 = 0.5f;
3780 const int32_t inputOffset1 = 5;
3781
3782 auto input1 = MakeTensor<T, 3>(inputTensorInfo1, std::vector<T>(
3783 {
3784 1, 2, 3,
3785 4, 5, 6,
3786 7, 8, 9,
3787 10, 11, 12,
3788 13, 14, 15,
3789 16, 17, 18,
3790
3791 19, 20, 21,
3792 22, 23, 24,
3793 25, 26, 27,
3794 28, 29, 30,
3795 31, 32, 33,
3796 34, 35, 36
3797 }));
3798
3799 // Quatized input2 tensor.
3800 const float inputScale2 = 0.2f;
3801 const int32_t inputOffset2 = 10;
3802
3803 auto input2 = MakeTensor<T, 3>(inputTensorInfo2, std::vector<T>(
3804 {
3805 37, 38, 39,
3806 40, 41, 42,
3807 43, 44, 45,
3808 46, 47, 48,
3809 49, 50, 51,
3810 52, 53, 54
3811 }));
3812
3813 // Quantized output tensor.
3814 const float outputScale = 0.1f;
3815 const int32_t outputOffset = 20;
3816
3817 LayerTestResult<T, 3> ret(outputTensorInfo);
3818
3819 ret.outputExpected = MakeTensor<T, 3>(outputTensorInfo, std::vector<T>(
3820 {
3821 0, 5, 74,
3822 10, 15, 76,
3823 20, 25, 78,
3824 30, 35, 80,
3825 40, 45, 82,
3826 50, 55, 84,
3827
3828 60, 65, 86,
3829 70, 75, 88,
3830 80, 85, 90,
3831 90, 95, 92,
3832 100, 105, 94,
3833 110, 115, 96,
3834
3835 120, 125, 98,
3836 130, 135, 100,
3837 140, 145, 102,
3838 150, 155, 104,
3839 160, 165, 106,
3840 170, 175, 108
3841 }));
3842
3843 outputTensorInfo.SetQuantizationScale(outputScale);
3844 outputTensorInfo.SetQuantizationOffset(outputOffset);
3845 inputTensorInfo1.SetQuantizationScale(inputScale1);
3846 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
3847 inputTensorInfo2.SetQuantizationScale(inputScale2);
3848 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
3849
3850 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
3851 armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
3852
3853 std::vector<unsigned int> wOrigin2 = { 0, 0, 2 }; //Extent of the window is defined by size of input[1].
3854 armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
3855
3856 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3857
3858 bool subTensorsSupported = useSubtensor && workloadFactory.SupportsSubTensors();
3859
3860 std::unique_ptr<armnn::ITensorHandle> inputHandle1 =
3861 subTensorsSupported ?
3862 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
3863 workloadFactory.CreateTensorHandle(inputTensorInfo1);
3864
3865 std::unique_ptr<armnn::ITensorHandle> inputHandle2 =
3866 subTensorsSupported ?
3867 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
3868 workloadFactory.CreateTensorHandle(inputTensorInfo2);
3869
3870 armnn::ConcatQueueDescriptor data;
3871 armnn::OriginsDescriptor desc = armnn::CreateDescriptorForConcatenation(
3872 inputTensorShapes.begin(),inputTensorShapes.end(), 2);
3873 data.m_Parameters = desc;
3874
3875 armnn::WorkloadInfo info;
3876 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
3877 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
3878 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
3879
3880 data.m_ViewOrigins.push_back(window1);
3881 data.m_ViewOrigins.push_back(window2);
3882
3883 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(data, info);
3884
3885 inputHandle1->Allocate();
3886 inputHandle2->Allocate();
3887 outputHandle->Allocate();
3888
3889 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0]);
3890 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0]);
3891
3892 workload->PostAllocationConfigure();
3893 workload->Execute();
3894
3895 CopyDataFromITensorHandle(&ret.output[0][0][0], outputHandle.get());
3896
3897 return ret;
3898}
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]3899
3900template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
3901LayerTestResult<T, 4> PreluTest(
3902 armnn::IWorkloadFactory& workloadFactory,
3903 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3904{
3905 armnn::TensorInfo inputTensorInfo ({ 1, 2, 2, 3 }, ArmnnType);
3906 armnn::TensorInfo alphaTensorInfo ({ 1, 1, 1, 3 }, ArmnnType);
3907 armnn::TensorInfo outputTensorInfo({ 1, 2, 2, 3 }, ArmnnType);
3908
3909 if (armnn::IsQuantizedType<T>())
3910 {
3911 inputTensorInfo.SetQuantizationScale(0.25f);
3912 inputTensorInfo.SetQuantizationOffset(128);
3913 alphaTensorInfo.SetQuantizationScale(0.25f);
3914 alphaTensorInfo.SetQuantizationOffset(50);
3915 outputTensorInfo.SetQuantizationScale(0.5f);
3916 outputTensorInfo.SetQuantizationOffset(120);
3917 }
3918
3919 std::vector<float> inputData
3920 {
3921 // Expected quantized values:
3922 // 128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120
3923 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f
3924 };
3925 std::vector<float> alphaData
3926 {
3927 // Expected quantized values:
3928 // 50, 54, 58
3929 0.0f, 1.0f, 2.0f
3930 };
3931 std::vector<float> outputExpectedData =
3932 {
3933 // Expected quantized values:
3934 // 20, 120, 120, 122, 122, 122, 120, 118, 116, 120, 116, 112
3935 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f
3936 };
3937
3938 auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3939 inputTensorInfo.GetQuantizationOffset(),
3940 inputData));
3941 auto alpha = MakeTensor<T, 4>(alphaTensorInfo, QuantizedVector<T>(alphaTensorInfo.GetQuantizationScale(),
3942 alphaTensorInfo.GetQuantizationOffset(),
3943 alphaData));
3944
3945 LayerTestResult<T, 4> result(outputTensorInfo);
3946 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3947 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3948 outputTensorInfo.GetQuantizationOffset(),
3949 outputExpectedData));
3950
3951 std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3952 std::unique_ptr <armnn::ITensorHandle> alphaHandle = workloadFactory.CreateTensorHandle(alphaTensorInfo);
3953 std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3954
3955 armnn::PreluQueueDescriptor descriptor;
3956 armnn::WorkloadInfo info;
3957 AddInputToWorkload (descriptor, info, inputTensorInfo, inputHandle.get());
3958 AddInputToWorkload (descriptor, info, alphaTensorInfo, alphaHandle.get());
3959 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3960
3961 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePrelu(descriptor, info);
3962
3963 inputHandle->Allocate();
3964 alphaHandle->Allocate();
3965 outputHandle->Allocate();
3966
3967 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3968 CopyDataToITensorHandle(alphaHandle.get(), &alpha[0][0][0][0]);
3969
3970 workload->Execute();
3971
3972 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3973
3974 return result;
3975}
3976
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]3977template<armnn::DataType ArmnnType,
3978 std::size_t InputDim,
3979 std::size_t OutputDim,
3980 typename T = armnn::ResolveType<ArmnnType>>
3981LayerTestResult<T, OutputDim> BatchToSpaceNdHelper(
3982 armnn::IWorkloadFactory &workloadFactory,
3983 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3984 const armnn::DataLayout& dataLayout,
3985 const unsigned int *inputShape,
3986 const std::vector<float> &inputData,
3987 const std::vector<unsigned int> &blockShape,
3988 const std::vector<std::pair<unsigned int, unsigned int>> &crops,
3989 const unsigned int *outputShape,
3990 const std::vector<float> &outputData,
3991 float scale = 1.0f,
3992 int32_t offset = 0)
3993{
3994 armnn::TensorInfo inputTensorInfo(InputDim, inputShape, ArmnnType);
3995 armnn::TensorInfo outputTensorInfo(OutputDim, outputShape, ArmnnType);
3996
3997 inputTensorInfo.SetQuantizationScale(scale);
3998 inputTensorInfo.SetQuantizationOffset(offset);
3999
4000 outputTensorInfo.SetQuantizationScale(scale);
4001 outputTensorInfo.SetQuantizationOffset(offset);
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]4002
Francis Murtagh57f13d52019-06-24 14:24:36 +0100[diff] [blame]4003 auto input = MakeTensor<T, InputDim>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputData, inputTensorInfo));
4004
4005 LayerTestResult<T, OutputDim> result(outputTensorInfo);
4006 result.outputExpected = MakeTensor<T, OutputDim>(outputTensorInfo,
4007 ConvertToDataType<ArmnnType>(outputData, outputTensorInfo));
4008
4009 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
4010 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4011
4012 armnn::BatchToSpaceNdQueueDescriptor data;
4013 data.m_Parameters.m_DataLayout = dataLayout;
4014 data.m_Parameters.m_BlockShape = blockShape;
4015 data.m_Parameters.m_Crops = crops;
4016 armnn::WorkloadInfo info;
4017 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
4018 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
4019
4020 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateBatchToSpaceNd(data, info);
4021
4022 inputHandle->Allocate();
4023 outputHandle->Allocate();
4024
4025 CopyDataToITensorHandle(inputHandle.get(), input.origin());
4026
4027 workload->PostAllocationConfigure();
4028 workload->Execute();
4029
4030 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
4031
4032 return result;
4033}
4034
4035template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4036LayerTestResult<T, 4> BatchToSpaceNdNhwcTest1(
4037 armnn::IWorkloadFactory& workloadFactory,
4038 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4039{
4040 const unsigned int inputShape[] = {4, 2, 2, 1};
4041 const unsigned int outputShape[] = {1, 4, 4, 1};
4042
4043 std::vector<float> input({
4044 // Batch 0, Height 0, Width (2) x Channel (1)
4045 1.0f, 3.0f,
4046 // Batch 0, Height 1, Width (2) x Channel (1)
4047 9.0f, 11.0f,
4048
4049
4050 // Batch 1, Height 0, Width (2) x Channel (1)
4051 2.0f, 4.0f,
4052 // Batch 1, Height 1, Width (2) x Channel (1)
4053 10.0f, 12.0f,
4054
4055
4056 // Batch 2, Height 0, Width (2) x Channel (1)
4057 5.0f, 7.0f,
4058 // Batch 2, Height 1, Width (2) x Channel (1)
4059 13.0f, 15.0f,
4060
4061 // Batch 3, Height 0, Width (2) x Channel (3)
4062 6.0f, 8.0f,
4063 // Batch 3, Height 1, Width (2) x Channel (1)
4064 14.0f, 16.0f
4065 });
4066
4067 std::vector<float> expectedOutput({
4068 1.0f, 2.0f, 3.0f, 4.0f,
4069 5.0f, 6.0f, 7.0f, 8.0f,
4070 9.0f, 10.0f, 11.0f, 12.0f,
4071 13.0f, 14.0f, 15.0f, 16.0f
4072 });
4073
4074 std::vector<unsigned int> blockShape {2, 2};
4075 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4076
4077 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4078 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4079 crops, outputShape, expectedOutput);
4080}
4081
4082template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4083LayerTestResult<T, 4> BatchToSpaceNdNhwcTest2(
4084 armnn::IWorkloadFactory& workloadFactory,
4085 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4086{
4087 const unsigned int inputShape[] = {4, 1, 1, 1};
4088 const unsigned int outputShape[] = {1, 2, 2, 1};
4089
4090 std::vector<float> input({
4091 // Batch 0, Height 0, Width (2) x Channel (1)
4092 1.0f, 2.0f, 3.0f, 4.0f
4093 });
4094
4095 std::vector<float> expectedOutput({1.0f, 2.0f, 3.0f, 4.0f});
4096
4097 std::vector<unsigned int> blockShape({2, 2});
4098 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4099
4100 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4101 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4102 crops, outputShape, expectedOutput);
4103}
4104
4105template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4106LayerTestResult<T, 4> BatchToSpaceNdNhwcTest3(
4107 armnn::IWorkloadFactory& workloadFactory,
4108 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4109{
4110 const unsigned int inputShape[] = {4, 1, 1, 3};
4111 const unsigned int outputShape[] = {1, 2, 2, 3};
4112
4113 std::vector<float> input({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f});
4114
4115 std::vector<float> expectedOutput({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f});
4116
4117 std::vector<unsigned int> blockShape({2, 2});
4118 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4119
4120 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4121 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4122 crops, outputShape, expectedOutput);
4123}
4124
4125template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4126LayerTestResult<T, 4> BatchToSpaceNdNhwcTest4(
4127 armnn::IWorkloadFactory& workloadFactory,
4128 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4129{
4130 const unsigned int inputShape[] = {8, 1, 3, 1};
4131 const unsigned int outputShape[] = {2, 2, 4, 1};
4132
4133 std::vector<float> input({
4134 0.0f, 1.0f, 3.0f,
4135 0.0f, 9.0f, 11.0f,
4136 0.0f, 2.0f, 4.0f,
4137 0.0f, 10.0f, 12.0f,
4138 0.0f, 5.0f, 7.0f,
4139 0.0f, 13.0f, 15.0f,
4140 0.0f, 6.0f, 8.0f,
4141 0.0f, 14.0f, 16.0f
4142 });
4143
4144 std::vector<float> expectedOutput({
4145 1.0f, 2.0f, 3.0f, 4.0f,
4146 5.0f, 6.0f, 7.0f, 8.0f,
4147 9.0f, 10.0f, 11.0f, 12.0f,
4148 13.0f, 14.0f, 15.0f, 16.0f
4149 });
4150
4151 std::vector<unsigned int> blockShape({2, 2});
4152 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {2, 0}};
4153
4154 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4155 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4156 crops, outputShape, expectedOutput);
4157}
4158
4159template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4160LayerTestResult<T, 4> BatchToSpaceNdNhwcTest5(
4161 armnn::IWorkloadFactory& workloadFactory,
4162 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4163{
4164 const unsigned int inputShape[] = {4, 2, 2, 1};
4165 const unsigned int outputShape[] = {1, 4, 4, 1};
4166
4167 std::vector<float> input({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16});
4168 std::vector<float> expectedOutput({1, 5, 2, 6, 9, 13, 10, 14, 3, 7, 4, 8, 11, 15, 12, 16});
4169
4170 std::vector<unsigned int> blockShape({2, 2});
4171 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4172
4173 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager, armnn::DataLayout::NHWC, inputShape,
4174 input, blockShape, crops, outputShape, expectedOutput);
4175}
4176
4177template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4178LayerTestResult<T, 4> BatchToSpaceNdNhwcTest6(
4179 armnn::IWorkloadFactory& workloadFactory,
4180 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4181{
4182 const unsigned int inputShape[] = {4, 1, 1, 1};
4183 const unsigned int outputShape[] = {1, 2, 2, 1};
4184
4185 std::vector<float> input({
4186 // Batch 0, Height 0, Width (2) x Channel (1)
4187 1, 2, 3, 4
4188 });
4189
4190 std::vector<float> expectedOutput({1, 2, 3, 4});
4191
4192 std::vector<unsigned int> blockShape({2, 2});
4193 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4194
4195 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4196 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4197 crops, outputShape, expectedOutput);
4198}
4199
4200template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4201LayerTestResult<T, 4> BatchToSpaceNdNhwcTest7(
4202 armnn::IWorkloadFactory& workloadFactory,
4203 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4204{
4205 const unsigned int inputShape[] = {4, 1, 1, 3};
4206 const unsigned int outputShape[] = {1, 2, 2, 3};
4207
4208 std::vector<float> input({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
4209
4210 std::vector<float> expectedOutput({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
4211
4212 std::vector<unsigned int> blockShape({2, 2});
4213 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4214
4215 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4216 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4217 crops, outputShape, expectedOutput);
4218}
4219
4220template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4221LayerTestResult<T, 4> BatchToSpaceNdNchwTest1(
4222 armnn::IWorkloadFactory &workloadFactory,
4223 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4224{
4225 const unsigned int inputShape[] = {4, 3, 1, 1};
4226 const unsigned int outputShape[] = {1, 3, 2, 2};
4227
4228 std::vector<float> input({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f});
4229
4230 std::vector<float> expectedOutput({
4231 // Batch 0, Channel 0, Height (2) x Width (2)
4232 1.0f, 4.0f,
4233 7.0f, 10.0f,
4234
4235 // Batch 0, Channel 1, Height (2) x Width (2)
4236 2.0f, 5.0f,
4237 8.0f, 11.0f,
4238
4239 // Batch 0, Channel 2, Height (2) x Width (2)
4240 3.0f, 6.0f,
4241 9.0f, 12.0f,
4242 });
4243
4244 std::vector<unsigned int> blockShape({2, 2});
4245 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4246
4247 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4248 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4249 crops, outputShape, expectedOutput);
4250}
4251
4252template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4253LayerTestResult<T, 4> BatchToSpaceNdNchwTest2(
4254 armnn::IWorkloadFactory& workloadFactory,
4255 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4256{
4257 const unsigned int inputShape[] = {4, 1, 1, 1};
4258 const unsigned int outputShape[] = {1, 1, 2, 2};
4259
4260 std::vector<float> input({
4261 // Batch 0, Height 0, Width (2) x Channel (1)
4262 1.0f, 2.0f, 3.0f, 4.0f
4263 });
4264
4265 std::vector<float> expectedOutput({1.0f, 2.0f, 3.0f, 4.0f});
4266
4267 std::vector<unsigned int> blockShape({2, 2});
4268 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4269
4270 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4271 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4272 crops, outputShape, expectedOutput);
4273}
4274
4275template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4276LayerTestResult<T, 4> BatchToSpaceNdNchwTest3(
4277 armnn::IWorkloadFactory& workloadFactory,
4278 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4279{
4280 const unsigned int inputShape[] = {4, 3, 1, 1};
4281 const unsigned int outputShape[] = {1, 3, 2, 2};
4282
4283 std::vector<float> input({1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f});
4284
4285 std::vector<float> expectedOutput({
4286 // Batch 0, Channel 0, Height (2) x Width (2)
4287 1.0f, 7.0f,
4288 2.0f, 8.0f,
4289
4290 // Batch 0, Channel 1, Height (2) x Width (2)
4291 3.0f, 9.0f,
4292 4.0f, 10.0f,
4293
4294 // Batch 0, Channel 2, Height (2) x Width (2)
4295 5.0f, 11.0f,
4296 6.0f, 12.0f,
4297 });
4298
4299 std::vector<unsigned int> blockShape({2, 2});
4300 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4301
4302 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4303 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4304 crops, outputShape, expectedOutput);
4305}
4306
4307template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4308LayerTestResult<T, 4> BatchToSpaceNdNchwTest4(
4309 armnn::IWorkloadFactory &workloadFactory,
4310 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4311{
4312 const unsigned int inputShape[] = {4, 3, 1, 1};
4313 const unsigned int outputShape[] = {1, 3, 2, 2};
4314
4315 std::vector<float> input({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
4316
4317 std::vector<float> expectedOutput({
4318 // Batch 0, Channel 0, Height (2) x Width (2)
4319 1, 4,
4320 7, 10,
4321
4322 // Batch 0, Channel 1, Height (2) x Width (2)
4323 2, 5,
4324 8, 11,
4325
4326 // Batch 0, Channel 2, Height (2) x Width (2)
4327 3, 6,
4328 9, 12,
4329 });
4330
4331 std::vector<unsigned int> blockShape({2, 2});
4332 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4333
4334 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4335 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4336 crops, outputShape, expectedOutput);
4337}
4338
4339template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4340LayerTestResult<T, 4> BatchToSpaceNdNchwTest5(
4341 armnn::IWorkloadFactory& workloadFactory,
4342 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4343{
4344 const unsigned int inputShape[] = {4, 1, 1, 1};
4345 const unsigned int outputShape[] = {1, 1, 2, 2};
4346
4347 std::vector<float> input({
4348 // Batch 0, Height 0, Width (2) x Channel (1)
4349 1, 2, 3, 4
4350 });
4351
4352 std::vector<float> expectedOutput({1, 2, 3, 4});
4353
4354 std::vector<unsigned int> blockShape({2, 2});
4355 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4356
4357 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4358 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4359 crops, outputShape, expectedOutput);
4360}
4361
4362template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4363LayerTestResult<T, 4> BatchToSpaceNdNchwTest6(
4364 armnn::IWorkloadFactory& workloadFactory,
4365 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4366{
4367 const unsigned int inputShape[] = {4, 3, 1, 1};
4368 const unsigned int outputShape[] = {1, 3, 2, 2};
4369
4370 std::vector<float> input({1, 3, 5, 7, 9, 11, 2, 4, 6, 8, 10, 12});
4371
4372 std::vector<float> expectedOutput({
4373 // Batch 0, Channel 0, Height (2) x Width (2)
4374 1, 7,
4375 2, 8,
4376
4377 // Batch 0, Channel 1, Height (2) x Width (2)
4378 3, 9,
4379 4, 10,
4380
4381 // Batch 0, Channel 2, Height (2) x Width (2)
4382 5, 11,
4383 6, 12,
4384 });
4385
4386 std::vector<unsigned int> blockShape({2, 2});
4387 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4388
4389 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4390 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4391 crops, outputShape, expectedOutput);
4392}
4393
4394template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4395LayerTestResult<T, 4> BatchToSpaceNdNchwTest7(
4396 armnn::IWorkloadFactory& workloadFactory,
4397 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4398{
4399 const unsigned int inputShape[] = {8, 1, 1, 3};
4400 const unsigned int outputShape[] = {2, 1, 2, 4};
4401
4402 std::vector<float> input({
4403 0, 1, 3, 0, 9, 11,
4404 0, 2, 4, 0, 10, 12,
4405 0, 5, 7, 0, 13, 15,
4406 0, 6, 8, 0, 14, 16
4407 });
4408
4409 std::vector<float> expectedOutput({
4410 1, 2, 3, 4,
4411 5, 6, 7, 8,
4412 9, 10, 11, 12,
4413 13, 14, 15, 16
4414 });
4415
4416 std::vector<unsigned int> blockShape({2, 2});
4417 std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {2, 0}};
4418
4419 return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4420 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4421 crops, outputShape, expectedOutput);
4422}
4423
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]4424template LayerTestResult<typename armnn::ResolveType<armnn::DataType::Float32>, 4>
4425PreluTest<armnn::DataType::Float32>(
4426 armnn::IWorkloadFactory& workloadFactory,
4427 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4428
4429template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
4430PreluTest<armnn::DataType::QuantisedAsymm8>(
4431 armnn::IWorkloadFactory& workloadFactory,
4432 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4433
4434template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
4435PreluTest<armnn::DataType::QuantisedSymm16>(
4436 armnn::IWorkloadFactory& workloadFactory,
4437 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
Aron Virginas-Tar735a4502019-06-26 15:02:47 +0100[diff] [blame]4438
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]4439template<armnn::DataType ArmnnType, typename T, std::size_t outputDimLength>
4440LayerTestResult<T, outputDimLength> StackTestHelper(
4441 armnn::IWorkloadFactory& workloadFactory,
4442 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4443 const armnn::TensorInfo& inputTensorInfo,
4444 const armnn::TensorInfo& outputTensorInfo,
4445 unsigned int axis,
4446 const std::vector<std::vector<T>>& inputData,
4447 const std::vector<T>& outputExpectedData)
4448{
4449 unsigned int numInputs = static_cast<unsigned int>(inputData.size());
4450 std::vector<boost::multi_array<T, outputDimLength-1>> inputs;
4451 for (unsigned int i = 0; i < numInputs; ++i)
4452 {
4453 inputs.push_back(MakeTensor<T, outputDimLength-1>(inputTensorInfo, inputData[i]));
4454 }
4455
4456 LayerTestResult<T, outputDimLength> result(outputTensorInfo);
4457 result.outputExpected = MakeTensor<T, outputDimLength>(outputTensorInfo, outputExpectedData);
4458
4459 std::vector<std::unique_ptr<armnn::ITensorHandle>> inputHandles;
4460 for (unsigned int i = 0; i < numInputs; ++i)
4461 {
4462 inputHandles.push_back(workloadFactory.CreateTensorHandle(inputTensorInfo));
4463 }
4464 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4465
4466 armnn::StackQueueDescriptor descriptor;
4467 descriptor.m_Parameters.m_Axis = axis;
4468 descriptor.m_Parameters.m_InputShape = inputTensorInfo.GetShape();
4469 descriptor.m_Parameters.m_NumInputs = numInputs;
4470
4471 armnn::WorkloadInfo info;
4472 for (unsigned int i = 0; i < numInputs; ++i)
4473 {
4474 std::unique_ptr<armnn::ITensorHandle>& inputHandle = inputHandles[i];
4475 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
4476 inputHandle->Allocate();
4477 CopyDataToITensorHandle(inputHandle.get(), inputs[i].origin());
4478 }
4479
4480 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
4481 outputHandle->Allocate();
4482
4483 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateStack(descriptor, info);
4484
4485 workload->Execute();
4486
4487 CopyDataFromITensorHandle(result.output.origin(), outputHandle.get());
4488
4489 return result;
4490}
4491
4492template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4493LayerTestResult<T, 4> Stack0AxisTest(
4494 armnn::IWorkloadFactory& workloadFactory,
4495 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4496{
4497 armnn::TensorInfo inputTensorInfo ({ 3, 2, 3 }, ArmnnType);
4498 armnn::TensorInfo outputTensorInfo({ 2, 3, 2, 3 }, ArmnnType);
4499
4500 std::vector<std::vector<T>> inputData;
4501
4502 inputData.push_back(
4503 {
4504 1, 2, 3,
4505 4, 5, 6,
4506
4507 7, 8, 9,
4508 10, 11, 12,
4509
4510 13, 14, 15,
4511 16, 17, 18
4512 });
4513
4514 inputData.push_back(
4515 {
4516 19, 20, 21,
4517 22, 23, 24,
4518
4519 25, 26, 27,
4520 28, 29, 30,
4521
4522 31, 32, 33,
4523 34, 35, 36
4524 });
4525
4526 std::vector<T> outputExpectedData =
4527 {
4528 1, 2, 3,
4529 4, 5, 6,
4530
4531 7, 8, 9,
4532 10, 11, 12,
4533
4534 13, 14, 15,
4535 16, 17, 18,
4536
4537
4538 19, 20, 21,
4539 22, 23, 24,
4540
4541 25, 26, 27,
4542 28, 29, 30,
4543
4544 31, 32, 33,
4545 34, 35, 36
4546 };
4547
4548 return StackTestHelper<ArmnnType, T, 4>(
4549 workloadFactory,
4550 memoryManager,
4551 inputTensorInfo,
4552 outputTensorInfo,
4553 0U,
4554 inputData,
4555 outputExpectedData
4556 );
4557}
4558
4559template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4560LayerTestResult<T, 4> Stack4dOutput1AxisTest(
4561 armnn::IWorkloadFactory& workloadFactory,
4562 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4563{
4564 armnn::TensorInfo inputTensorInfo ({ 3, 2, 3 }, ArmnnType);
4565 armnn::TensorInfo outputTensorInfo({ 3, 2, 2, 3 }, ArmnnType);
4566
4567 std::vector<std::vector<T>> inputData;
4568
4569 inputData.push_back(
4570 {
4571 1, 2, 3,
4572 4, 5, 6,
4573
4574 7, 8, 9,
4575 10, 11, 12,
4576
4577 13, 14, 15,
4578 16, 17, 18
4579 });
4580
4581 inputData.push_back(
4582 {
4583 19, 20, 21,
4584 22, 23, 24,
4585
4586 25, 26, 27,
4587 28, 29, 30,
4588
4589 31, 32, 33,
4590 34, 35, 36
4591 });
4592
4593 std::vector<T> outputExpectedData =
4594 {
4595 1, 2, 3,
4596 4, 5, 6,
4597
4598 19, 20, 21,
4599 22, 23, 24,
4600
4601
4602 7, 8, 9,
4603 10, 11, 12,
4604
4605 25, 26, 27,
4606 28, 29, 30,
4607
4608
4609 13, 14, 15,
4610 16, 17, 18,
4611
4612 31, 32, 33,
4613 34, 35, 36
4614 };
4615
4616 return StackTestHelper<ArmnnType, T, 4>(
4617 workloadFactory,
4618 memoryManager,
4619 inputTensorInfo,
4620 outputTensorInfo,
4621 1U,
4622 inputData,
4623 outputExpectedData
4624 );
4625}
4626
4627template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4628LayerTestResult<T, 4> Stack4dOutput2AxisTest(
4629 armnn::IWorkloadFactory& workloadFactory,
4630 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4631{
4632 armnn::TensorInfo inputTensorInfo ({ 3, 2, 3 }, ArmnnType);
4633 armnn::TensorInfo outputTensorInfo({ 3, 2, 2, 3 }, ArmnnType);
4634
4635 std::vector<std::vector<T>> inputData;
4636
4637 inputData.push_back(
4638 {
4639 1, 2, 3,
4640 4, 5, 6,
4641
4642 7, 8, 9,
4643 10, 11, 12,
4644
4645 13, 14, 15,
4646 16, 17, 18
4647 });
4648
4649 inputData.push_back(
4650 {
4651 19, 20, 21,
4652 22, 23, 24,
4653
4654 25, 26, 27,
4655 28, 29, 30,
4656
4657 31, 32, 33,
4658 34, 35, 36
4659 });
4660
4661 std::vector<T> outputExpectedData =
4662 {
4663 1, 2, 3,
4664 19, 20, 21,
4665
4666 4, 5, 6,
4667 22, 23, 24,
4668
4669
4670 7, 8, 9,
4671 25, 26, 27,
4672
4673 10, 11, 12,
4674 28, 29, 30,
4675
4676 13, 14, 15,
4677 31, 32, 33,
4678
4679 16, 17, 18,
4680 34, 35, 36
4681 };
4682
4683 return StackTestHelper<ArmnnType, T, 4>(
4684 workloadFactory,
4685 memoryManager,
4686 inputTensorInfo,
4687 outputTensorInfo,
4688 2U,
4689 inputData,
4690 outputExpectedData
4691 );
4692}
4693
4694template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4695LayerTestResult<T, 4> Stack4dOutput3AxisTest(
4696 armnn::IWorkloadFactory& workloadFactory,
4697 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4698{
4699 armnn::TensorInfo inputTensorInfo ({ 3, 2, 3 }, ArmnnType);
4700 armnn::TensorInfo outputTensorInfo({ 3, 2, 3, 2 }, ArmnnType);
4701
4702 std::vector<std::vector<T>> inputData;
4703
4704 inputData.push_back(
4705 {
4706 1, 2, 3,
4707 4, 5, 6,
4708
4709 7, 8, 9,
4710 10, 11, 12,
4711
4712 13, 14, 15,
4713 16, 17, 18
4714 });
4715
4716 inputData.push_back(
4717 {
4718 19, 20, 21,
4719 22, 23, 24,
4720
4721 25, 26, 27,
4722 28, 29, 30,
4723
4724 31, 32, 33,
4725 34, 35, 36
4726 });
4727
4728 std::vector<T> outputExpectedData =
4729 {
4730 1, 19,
4731 2, 20,
4732 3, 21,
4733
4734 4, 22,
4735 5, 23,
4736 6, 24,
4737
4738
4739 7, 25,
4740 8, 26,
4741 9, 27,
4742
4743 10, 28,
4744 11, 29,
4745 12, 30,
4746
4747
4748 13, 31,
4749 14, 32,
4750 15, 33,
4751
4752 16, 34,
4753 17, 35,
4754 18, 36
4755 };
4756
4757 return StackTestHelper<ArmnnType, T, 4>(
4758 workloadFactory,
4759 memoryManager,
4760 inputTensorInfo,
4761 outputTensorInfo,
4762 3U,
4763 inputData,
4764 outputExpectedData
4765 );
4766}
4767
4768template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4769LayerTestResult<T, 3> Stack3dOutput1Axis3InputTest(
4770 armnn::IWorkloadFactory& workloadFactory,
4771 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4772{
4773 armnn::TensorInfo inputTensorInfo ({ 3, 3 }, ArmnnType);
4774 armnn::TensorInfo outputTensorInfo({ 3, 3, 3 }, ArmnnType);
4775
4776 std::vector<std::vector<T>> inputData;
4777
4778 inputData.push_back(
4779 {
4780 1, 2, 3,
4781 4, 5, 6,
4782 7, 8, 9
4783 });
4784
4785 inputData.push_back(
4786 {
4787 10, 11, 12,
4788 13, 14, 15,
4789 16, 17, 18
4790 });
4791
4792 inputData.push_back(
4793 {
4794 19, 20, 21,
4795 22, 23, 24,
4796 25, 26, 27
4797 });
4798
4799 std::vector<T> outputExpectedData =
4800 {
4801 1, 2, 3,
4802 10, 11, 12,
4803 19, 20, 21,
4804
4805 4, 5, 6,
4806 13, 14, 15,
4807 22, 23, 24,
4808
4809 7, 8, 9,
4810 16, 17, 18,
4811 25, 26, 27
4812 };
4813
4814 return StackTestHelper<ArmnnType, T, 3>(
4815 workloadFactory,
4816 memoryManager,
4817 inputTensorInfo,
4818 outputTensorInfo,
4819 1U,
4820 inputData,
4821 outputExpectedData
4822 );
4823}
Matthew Jacksondba634f2019-08-15 15:14:18 +0100[diff] [blame]4824
4825template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4826LayerTestResult<T, 5> Stack5dOutputTest(
4827 armnn::IWorkloadFactory& workloadFactory,
4828 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4829{
4830 armnn::TensorInfo inputTensorInfo ({ 2, 2, 2, 3 }, ArmnnType);
4831 armnn::TensorInfo outputTensorInfo({ 2, 2, 2, 2, 3 }, ArmnnType);
4832
4833 std::vector<std::vector<T>> inputData;
4834
4835 inputData.push_back(
4836 {
4837 1, 2, 3,
4838 4, 5, 6,
4839
4840 7, 8, 9,
4841 10, 11, 12,
4842
4843
4844 13, 14, 15,
4845 16, 17, 18,
4846
4847 19, 20, 21,
4848 22, 23, 24
4849 });
4850
4851 inputData.push_back(
4852 {
4853 25, 26, 27,
4854 28, 29, 30,
4855
4856 31, 32, 33,
4857 34, 35, 36,
4858
4859
4860 37, 38, 39,
4861 40, 41, 42,
4862
4863 43, 44, 45,
4864 46, 47, 48
4865 });
4866
4867 std::vector<T> outputExpectedData =
4868 {
4869 1, 2, 3,
4870 4, 5, 6,
4871
4872 7, 8, 9,
4873 10, 11, 12,
4874
4875
4876 25, 26, 27,
4877 28, 29, 30,
4878
4879 31, 32, 33,
4880 34, 35, 36,
4881
4882
4883
4884 13, 14, 15,
4885 16, 17, 18,
4886
4887 19, 20, 21,
4888 22, 23, 24,
4889
4890
4891 37, 38, 39,
4892 40, 41, 42,
4893
4894 43, 44, 45,
4895 46, 47, 48
4896
4897 };
4898
4899 return StackTestHelper<ArmnnType, T, 5>(
4900 workloadFactory,
4901 memoryManager,
4902 inputTensorInfo,
4903 outputTensorInfo,
4904 1U,
4905 inputData,
4906 outputExpectedData
4907 );
4908}