ArmNN
 22.05.01
Pooling3dTestImpl.cpp
Go to the documentation of this file.
1 //
2 // Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 
7 #include "Pooling3dTestImpl.hpp"
8 
9 #include <armnnUtils/QuantizeHelper.hpp>
10 #include <ResolveType.hpp>
11 
12 #include <armnnUtils/TensorUtils.hpp>
13 #include <armnnUtils/DataLayoutIndexed.hpp>
14 #include <armnnUtils/Permute.hpp>
15 
16 #include <armnn/utility/IgnoreUnused.hpp>
17 #include <armnn/utility/NumericCast.hpp>
18 
19 #include <armnn/BackendHelper.hpp>
20 #include <backendsCommon/WorkloadInfo.hpp>
21 
22 #include <armnnTestUtils/TensorCopyUtils.hpp>
23 #include <armnnTestUtils/WorkloadTestUtils.hpp>
24 
25 #include <armnnTestUtils/TensorHelpers.hpp>
26 
27 namespace
28 {
29 
30 using namespace armnnUtils;
31 
32 template<typename T>
33 void PermuteNCDHWToNDHWC(std::vector<T> &src, armnn::TensorInfo &srcInfo)
34 {
35  const armnn::PermutationVector NCDHWToNDHWC = { 0, 4, 1, 2, 3 };
36  std::vector<T> tmp(src.size());
37  armnnUtils::Permute(srcInfo.GetShape(), NCDHWToNDHWC, src.data(), tmp.data(), sizeof(T));
38  src = tmp;
39 }
40 
41 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
42 LayerTestResult<T, 5> SimplePooling3dTestImpl(
43  armnn::IWorkloadFactory& workloadFactory,
44  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
45  const armnn::ITensorHandleFactory& tensorHandleFactory,
46  armnn::Pooling3dDescriptor descriptor,
47  float qScale,
48  int32_t qOffset,
49  const std::vector<T>& input,
50  const std::vector<T>& outputExpected,
51  const armnn::TensorShape& inputShape,
52  const armnn::TensorShape& outputShape)
53 {
54  IgnoreUnused(memoryManager);
55  const armnn::DataLayout dataLayout = descriptor.m_DataLayout;
56  const armnnUtils::DataLayoutIndexed dimensionIndices = dataLayout;
57  auto heightIndex = dimensionIndices.GetHeightIndex();
58  auto widthIndex = dimensionIndices.GetWidthIndex();
59  auto depthIndex = dimensionIndices.GetDepthIndex();
60  auto channelsIndex = dimensionIndices.GetChannelsIndex();
61 
62  unsigned int inputDepth = armnn::numeric_cast<unsigned int>(inputShape[depthIndex]);
63  unsigned int inputHeight = armnn::numeric_cast<unsigned int>(inputShape[heightIndex]);
64  unsigned int inputWidth = armnn::numeric_cast<unsigned int>(inputShape[widthIndex]);
65  unsigned int inputChannels = armnn::numeric_cast<unsigned int>(inputShape[channelsIndex]);
66  unsigned int inputBatchSize = armnn::numeric_cast<unsigned int>(inputShape[0]);
67 
68  unsigned int outputDepth = armnn::numeric_cast<unsigned int>(outputShape[depthIndex]);
69  unsigned int outputHeight = armnn::numeric_cast<unsigned int>(outputShape[heightIndex]);
70  unsigned int outputWidth = armnn::numeric_cast<unsigned int>(outputShape[widthIndex]);
71  unsigned int outputChannels = armnn::numeric_cast<unsigned int>(outputShape[channelsIndex]);
72  unsigned int outputBatchSize = armnn::numeric_cast<unsigned int>(outputShape[0]);
73 
74  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(
75  inputBatchSize, inputChannels, inputDepth, inputHeight, inputWidth, dataLayout, ArmnnType);
76 
77  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(
78  outputBatchSize, outputChannels, outputDepth, outputHeight, outputWidth, dataLayout, ArmnnType);
79 
80  // Set quantization parameters if the requested type is a quantized type.
81  if (armnn::IsQuantizedType<T>())
82  {
83  inputTensorInfo.SetQuantizationScale(qScale);
84  inputTensorInfo.SetQuantizationOffset(qOffset);
85  outputTensorInfo.SetQuantizationScale(qScale);
86  outputTensorInfo.SetQuantizationOffset(qOffset);
87  }
88 
89  LayerTestResult<T, 5> result(outputTensorInfo);
90  std::vector<T> actualOutput(outputTensorInfo.GetNumElements());
91 
92  std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
93  std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
94 
95  armnn::Pooling3dQueueDescriptor queueDescriptor;
96  queueDescriptor.m_Parameters = descriptor;
97  queueDescriptor.m_Parameters.m_DataLayout = dataLayout;
98 
99  armnn::WorkloadInfo workloadInfo;
100  AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfo, inputHandle.get());
101  AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
102 
103  // Don't execute if Pooling is not supported, as an exception will be raised.
104  armnn::BackendId backend = workloadFactory.GetBackendId();
105  std::string reasonIfUnsupported;
106  armnn::LayerSupportHandle handle = armnn::GetILayerSupportByBackendId(backend);
107  result.m_Supported = handle.IsPooling3dSupported(inputTensorInfo,
108  outputTensorInfo,
109  queueDescriptor.m_Parameters,
110  reasonIfUnsupported);
111  if (!result.m_Supported)
112  {
113  return result;
114  }
115 
116  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateWorkload(armnn::LayerType::Pooling3d,
117  queueDescriptor,
118  workloadInfo);
119 
120  inputHandle->Allocate();
121  outputHandle->Allocate();
122 
123  CopyDataToITensorHandle(inputHandle.get(), input.data());
124 
125  workload->Execute();
126 
127  CopyDataFromITensorHandle(actualOutput.data(), outputHandle.get());
128 
129  result.m_ActualData = actualOutput;
130  result.m_ExpectedData = outputExpected;
131 
132  return result;
133 }
134 
135 //
136 // Tests max pooling with the following parameters:
137 //
138 // Pooling size: 2x2x2
139 // Stride: (1,1,1)
140 // input size: 3x3x3
141 // channels: 2
142 // batch size: 2
143 //
144 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
145 LayerTestResult<T, 5> SimpleMaxPooling3dSize2x2x2Stride1x1x1TestCommon(
146  armnn::IWorkloadFactory& workloadFactory,
147  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
148  const armnn::ITensorHandleFactory& tensorHandleFactory,
149  const armnn::DataLayout dataLayout,
150  float qScale = 1.0f,
151  int32_t qOffset = 0)
152 {
153  armnn::Pooling3dDescriptor descriptor;
154  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
155  descriptor.m_PoolWidth = 2;
156  descriptor.m_PoolHeight = 2;
157  descriptor.m_PoolDepth = 2;
158  descriptor.m_StrideX = 1;
159  descriptor.m_StrideY = 1;
160  descriptor.m_StrideZ = 1;
161  descriptor.m_PadLeft = descriptor.m_PadRight = 0;
162  descriptor.m_PadTop = descriptor.m_PadBottom = 0;
163  descriptor.m_PadFront = descriptor.m_PadBack = 0;
164  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
165  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
166  descriptor.m_DataLayout = dataLayout;
167 
168  unsigned int inputWidth = 3;
169  unsigned int inputHeight = 3;
170  unsigned int inputDepth = 3;
171  unsigned int outputWidth =
172  (inputWidth + descriptor.m_PadLeft + descriptor.m_PadRight + descriptor.m_StrideX - descriptor.m_PoolWidth) /
173  descriptor.m_StrideX;
174  unsigned int outputHeight =
175  (inputHeight + descriptor.m_PadTop + descriptor.m_PadBottom + descriptor.m_StrideY - descriptor.m_PoolHeight) /
176  descriptor.m_StrideY;
177  unsigned int outputDepth =
178  (inputDepth + descriptor.m_PadFront + descriptor.m_PadBack + descriptor.m_StrideZ - descriptor.m_PoolDepth) /
179  descriptor.m_StrideZ;
180  unsigned int channels = 2;
181  unsigned int batchSize = 2;
182 
183  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( batchSize, channels, inputDepth, inputHeight,
184  inputWidth, dataLayout, ArmnnType);
185  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( batchSize, channels, outputDepth, outputHeight,
186  outputWidth, dataLayout, ArmnnType);
187 
188  // Set quantization parameters if the requested type is a quantized type.
189  if(armnn::IsQuantizedType<T>())
190  {
191  inputTensorInfo.SetQuantizationScale(qScale);
192  inputTensorInfo.SetQuantizationOffset(qOffset);
193  outputTensorInfo.SetQuantizationScale(qScale);
194  outputTensorInfo.SetQuantizationOffset(qOffset);
195  }
196 
197  std::vector<float> singleChannelData({
198  1.0f, 1.0f, 1.0f,
199  1.0f, 1.0f, 1.0f,
200  1.0f, 1.0f, 1.0f,
201 
202  1.0f, 1.0f, 1.0f,
203  1.0f, 1.0f, 1.0f,
204  1.0f, 1.0f, 1.0f,
205 
206  1.0f, 1.0f, 1.0f,
207  1.0f, 1.0f, 1.0f,
208  1.0f, 1.0f, 1.0f,
209  });
210 
211  // Constructs input data.
212  std::vector<float> inputData;
213  auto negator = [](float f) { return -f; };
214 
215  // First image (two channels where the second channel is the negative of the first one).
216  inputData.insert(inputData.end(), singleChannelData.begin(), singleChannelData.end());
217  std::transform(singleChannelData.begin(), singleChannelData.end(), std::back_inserter(inputData), negator);
218 
219  // Second image (same as first image).
220  inputData.insert(inputData.end(), singleChannelData.begin(), singleChannelData.end());
221  std::transform(singleChannelData.begin(), singleChannelData.end(), std::back_inserter(inputData), negator);
222 
223  auto input = QuantizedVector<T>(inputData, qScale, qOffset);
224 
225  // These were calculated manually.
226  std::vector<T> outputExpected = QuantizedVector<T>(
227  {
228  1.0f, 1.0f,
229  1.0f, 1.0f,
230 
231  1.0f, 1.0f,
232  1.0f, 1.0f,
233 
234  -1.0f, -1.0f,
235  -1.0f, -1.0f,
236 
237  -1.0f, -1.0f,
238  -1.0f, -1.0f,
239 
240 
241  1.0f, 1.0f,
242  1.0f, 1.0f,
243 
244  1.0f, 1.0f,
245  1.0f, 1.0f,
246 
247  -1.0f, -1.0f,
248  -1.0f, -1.0f,
249 
250  -1.0f, -1.0f,
251  -1.0f, -1.0f,
252  },
253  qScale, qOffset);
254 
255  if (dataLayout == armnn::DataLayout::NDHWC)
256  {
257  PermuteNCDHWToNDHWC(input, inputTensorInfo);
258  PermuteNCDHWToNDHWC(outputExpected, outputTensorInfo);
259  }
260 
261  return SimplePooling3dTestImpl<ArmnnType>(
262  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
263  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
264 }
265 
266 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
267 LayerTestResult<T, 5> SimpleMaxPooling3dTestCommon(
268  armnn::IWorkloadFactory& workloadFactory,
269  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
270  const armnn::ITensorHandleFactory& tensorHandleFactory,
271  const armnn::DataLayout dataLayout,
272  float qScale = 1.0f,
273  int32_t qOffset = 0)
274 {
275  armnn::Pooling3dDescriptor descriptor;
276  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
277  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 2;
278  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 2;
279  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
280  descriptor.m_DataLayout = dataLayout;
281 
282  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(1, 1, 4, 4, 4, dataLayout, ArmnnType);
283  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(1, 1, 2, 2, 2, dataLayout, ArmnnType);
284 
285  // Set quantization parameters if the requested type is a quantized type.
286  if(armnn::IsQuantizedType<T>())
287  {
288  inputTensorInfo.SetQuantizationScale(qScale);
289  inputTensorInfo.SetQuantizationOffset(qOffset);
290  outputTensorInfo.SetQuantizationScale(qScale);
291  outputTensorInfo.SetQuantizationOffset(qOffset);
292  }
293 
294  std::vector<T> inputData(
295  QuantizedVector<T>({
296  1.0f, 2.0f, 5.0f, 6.0f,
297  3.0f, 4.0f, 7.0f, 8.0f,
298  9.0f, 10.0f, 13.0f, 14.0f,
299  11.0f, 12.0f, 15.0f, 16.0f,
300 
301  17.0f, 18.0f, 21.0f, 22.0f,
302  19.0f, 20.0f, 23.0f, 24.0f,
303  25.0f, 26.0f, 29.0f, 30.0f,
304  27.0f, 28.0f, 31.0f, 32.0f,
305 
306  33.0f, 34.0f, 37.0f, 38.0f,
307  35.0f, 36.0f, 39.0f, 40.0f,
308  41.0f, 42.0f, 45.0f, 46.0f,
309  43.0f, 44.0f, 47.0f, 48.0f,
310 
311  49.0f, 50.0f, 53.0f, 54.0f,
312  51.0f, 52.0f, 55.0f, 56.0f,
313  57.0f, 58.0f, 61.0f, 62.0f,
314  59.0f, 60.0f, 63.0f, 64.0f,
315  },
316  qScale, qOffset));
317 
318  std::vector<T> outputData(
319  QuantizedVector<T>({
320  20.0f, 24.0f,
321  28.0f, 32.0f,
322 
323  52.0f, 56.0f,
324  60.0f, 64.0f,
325  },
326  qScale, qOffset));
327 
328  if (dataLayout == armnn::DataLayout::NDHWC)
329  {
330  PermuteNCDHWToNDHWC(inputData, inputTensorInfo);
331  PermuteNCDHWToNDHWC(outputData, outputTensorInfo);
332  }
333 
334  return SimplePooling3dTestImpl<ArmnnType>(
335  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
336  inputData, outputData, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
337 }
338 
339 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
340 LayerTestResult<T, 5> IgnorePaddingSimpleMaxPooling3dTestCommon(
341  armnn::IWorkloadFactory& workloadFactory,
342  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
343  const armnn::ITensorHandleFactory& tensorHandleFactory,
344  const armnn::DataLayout dataLayout,
345  float qScale = 1.0f,
346  int32_t qOffset = 0)
347 {
348  armnn::Pooling3dDescriptor descriptor;
349  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
350  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 2;
351  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 2;
352  descriptor.m_PadLeft = 1;
353  descriptor.m_PadRight = 1;
354  descriptor.m_PadTop = 1;
355  descriptor.m_PadBottom = 1;
356  descriptor.m_PadFront = 1;
357  descriptor.m_PadBack = 1;
358  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
359  descriptor.m_DataLayout = dataLayout;
360 
361  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 4, 4, 4 , dataLayout, ArmnnType);
362  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 3, 3, 3 , dataLayout, ArmnnType);
363 
364  // Set quantization parameters if the requested type is a quantized type.
365  if(armnn::IsQuantizedType<T>())
366  {
367  inputTensorInfo.SetQuantizationScale(qScale);
368  inputTensorInfo.SetQuantizationOffset(qOffset);
369  outputTensorInfo.SetQuantizationScale(qScale);
370  outputTensorInfo.SetQuantizationOffset(qOffset);
371  }
372 
373  auto input = QuantizedVector<T>(
374  {
375  -1.0f, -2.0f, 3.0f, 4.0f,
376  -1.0f, -2.0f, 3.0f, 4.0f,
377  1.0f, 2.0f, -3.0f, -4.0f,
378  1.0f, 2.0f, -3.0f, -4.0f,
379 
380  -1.0f, -2.0f, 3.0f, 4.0f,
381  -1.0f, -2.0f, 3.0f, 4.0f,
382  1.0f, 2.0f, -3.0f, -4.0f,
383  1.0f, 2.0f, -3.0f, -4.0f,
384 
385  -1.0f, -2.0f, 3.0f, 4.0f,
386  -1.0f, -2.0f, 3.0f, 4.0f,
387  1.0f, 2.0f, -3.0f, -4.0f,
388  1.0f, 2.0f, -3.0f, -4.0f,
389 
390  -1.0f, -2.0f, 3.0f, 4.0f,
391  -1.0f, -2.0f, 3.0f, 4.0f,
392  1.0f, 2.0f, -3.0f, -4.0f,
393  1.0f, 2.0f, -3.0f, -4.0f,
394  },
395  qScale, qOffset);
396 
397  auto outputExpected = QuantizedVector<T>(
398  {
399  -1.0f, 3.0f, 4.0f,
400  1.0f, 3.0f, 4.0f,
401  1.0f, 2.0f, -4.0f,
402 
403  -1.0f, 3.0f, 4.0f,
404  1.0f, 3.0f, 4.0f,
405  1.0f, 2.0f, -4.0f,
406 
407  -1.0f, 3.0f, 4.0f,
408  1.0f, 3.0f, 4.0f,
409  1.0f, 2.0f, -4.0f,
410  },
411  qScale, qOffset);
412 
413  if (dataLayout == armnn::DataLayout::NDHWC)
414  {
415  PermuteNCDHWToNDHWC(input, inputTensorInfo);
416  PermuteNCDHWToNDHWC(outputExpected, outputTensorInfo);
417  }
418 
419  return SimplePooling3dTestImpl<ArmnnType>(
420  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
421  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
422 }
423 
424 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
425 LayerTestResult<T, 5> SimpleAveragePooling3dTestCommon(
426  armnn::IWorkloadFactory& workloadFactory,
427  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
428  const armnn::ITensorHandleFactory& tensorHandleFactory,
429  armnn::DataLayout dataLayout = armnn::DataLayout::NCDHW,
430  float qScale = 1.0f,
431  int32_t qOffset = 0)
432 {
433  armnn::Pooling3dDescriptor descriptor;
434  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
435  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 2;
436  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 2;
437  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
438  descriptor.m_DataLayout = dataLayout;
439 
440  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(1, 1, 4, 4, 4, dataLayout, ArmnnType);
441  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(1, 1, 2, 2, 2, dataLayout, ArmnnType);
442 
443  // Set quantization parameters if the requested type is a quantized type.
444  if(armnn::IsQuantizedType<T>())
445  {
446  inputTensorInfo.SetQuantizationScale(qScale);
447  inputTensorInfo.SetQuantizationOffset(qOffset);
448  outputTensorInfo.SetQuantizationScale(qScale);
449  outputTensorInfo.SetQuantizationOffset(qOffset);
450  }
451 
452  std::vector<T> inputData(
453  QuantizedVector<T>({
454  1.0f, 2.0f, 5.0f, 6.0f,
455  3.0f, 4.0f, 7.0f, 8.0f,
456  9.0f, 10.0f, 13.0f, 14.0f,
457  11.0f, 12.0f, 15.0f, 16.0f,
458 
459  17.0f, 18.0f, 21.0f, 22.0f,
460  19.0f, 20.0f, 23.0f, 24.0f,
461  25.0f, 26.0f, 29.0f, 30.0f,
462  27.0f, 28.0f, 31.0f, 32.0f,
463 
464  33.0f, 34.0f, 37.0f, 38.0f,
465  35.0f, 36.0f, 39.0f, 40.0f,
466  41.0f, 42.0f, 45.0f, 46.0f,
467  43.0f, 44.0f, 47.0f, 48.0f,
468 
469  49.0f, 50.0f, 53.0f, 54.0f,
470  51.0f, 52.0f, 55.0f, 56.0f,
471  57.0f, 58.0f, 61.0f, 62.0f,
472  59.0f, 60.0f, 63.0f, 64.0f,
473  },
474  qScale, qOffset));
475 
476  std::vector<T> outputData(
477  QuantizedVector<T>({
478  10.5f, 14.5f,
479  18.5f, 22.5f,
480 
481  42.5f, 46.5f,
482  50.5f, 54.5f,
483  },
484  qScale, qOffset));
485 
486  if (dataLayout == armnn::DataLayout::NDHWC)
487  {
488  PermuteNCDHWToNDHWC(inputData, inputTensorInfo);
489  PermuteNCDHWToNDHWC(outputData, outputTensorInfo);
490  }
491 
492  return SimplePooling3dTestImpl<ArmnnType>(
493  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
494  inputData, outputData, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
495 }
496 
497 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
498 LayerTestResult<T, 5> LargeTensorsAveragePooling3dTestCommon(
499  armnn::IWorkloadFactory& workloadFactory,
500  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
501  const armnn::ITensorHandleFactory& tensorHandleFactory,
502  const armnn::DataLayout dataLayout,
503  float qScale = 1.0f,
504  int32_t qOffset = 0)
505 {
506  armnn::Pooling3dDescriptor descriptor;
507  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
508  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 100;
509  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 5;
510  descriptor.m_PadLeft = 50;
511  descriptor.m_PadRight = 50;
512  descriptor.m_PadTop = 50;
513  descriptor.m_PadBottom = 50;
514  descriptor.m_PadFront = 50;
515  descriptor.m_PadBack = 50;
516  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
517  descriptor.m_DataLayout = dataLayout;
518 
519  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 5, 3, 52, 60, 68, dataLayout, ArmnnType);
520  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 5, 3, 11, 13, 14, dataLayout, ArmnnType);
521 
522  // Set quantization parameters if the requested type is a quantized type.armnnUtils::GetTensorInfo(
523  if(armnn::IsQuantizedType<T>())
524  {
525  inputTensorInfo.SetQuantizationScale(qScale);
526  inputTensorInfo.SetQuantizationOffset(qOffset);
527  outputTensorInfo.SetQuantizationScale(qScale);
528  outputTensorInfo.SetQuantizationOffset(qOffset);
529  }
530 
531  std::vector<T> input;
532 
533  for (unsigned int i = 0 ; i < inputTensorInfo.GetShape().GetNumElements(); ++i)
534  {
535  input.push_back(1);
536  }
537 
538  std::vector<T> outputExpected;
539 
540  for (unsigned int i = 0 ; i < outputTensorInfo.GetShape().GetNumElements(); ++i)
541  {
542  outputExpected.push_back(1);
543  }
544 
545  return SimplePooling3dTestImpl<ArmnnType>(
546  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
547  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
548 }
549 
550 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
551 LayerTestResult<T, 5> IgnorePaddingSimpleAveragePooling3dTestCommon(
552  armnn::IWorkloadFactory& workloadFactory,
553  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
554  const armnn::ITensorHandleFactory& tensorHandleFactory,
555  const armnn::DataLayout dataLayout,
556  float qScale = 1.0f,
557  int32_t qOffset = 0)
558 {
559  armnn::Pooling3dDescriptor descriptor;
560  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
561  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 2;
562  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 2;
563  descriptor.m_PadLeft = 1;
564  descriptor.m_PadRight = 1;
565  descriptor.m_PadTop = 1;
566  descriptor.m_PadBottom = 1;
567  descriptor.m_PadFront = 1;
568  descriptor.m_PadBack = 1;
569  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
570  descriptor.m_DataLayout = dataLayout;
571 
572 
573  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo ( 1, 1, 4, 4, 4, dataLayout, ArmnnType);
574  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 3, 3, 3, dataLayout, ArmnnType);
575 
576  // Set quantization parameters if the requested type is a quantized type.
577  if(armnn::IsQuantizedType<T>())
578  {
579  inputTensorInfo.SetQuantizationScale(qScale);
580  inputTensorInfo.SetQuantizationOffset(qOffset);
581  outputTensorInfo.SetQuantizationScale(qScale);
582  outputTensorInfo.SetQuantizationOffset(qOffset);
583  }
584 
585  auto input = QuantizedVector<T>(
586  {
587  12.0f, 20.0f, 32.0f, 40.0f,
588  12.0f, 20.0f, 32.0f, 40.0f,
589  12.0f, 20.0f, 32.0f, 40.0f,
590  12.0f, 20.0f, 32.0f, 40.0f,
591 
592  24.0f, 40.0f, 64.0f, 80.0f,
593  24.0f, 40.0f, 64.0f, 80.0f,
594  24.0f, 40.0f, 64.0f, 80.0f,
595  24.0f, 40.0f, 64.0f, 80.0f,
596 
597  36.0f, 60.0f, 96.0f, 120.0f,
598  36.0f, 60.0f, 96.0f, 120.0f,
599  36.0f, 60.0f, 96.0f, 120.0f,
600  36.0f, 60.0f, 96.0f, 120.0f,
601 
602  48.0f, 80.0f, 128.0f, 160.0f,
603  48.0f, 80.0f, 128.0f, 160.0f,
604  48.0f, 80.0f, 128.0f, 160.0f,
605  48.0f, 80.0f, 128.0f, 160.0f,
606  },
607  qScale, qOffset);
608 
609  auto outputExpected = QuantizedVector<T>(
610  {
611  1.5f, 6.5f, 5.0f,
612  3.0f, 13.0f, 10.0f,
613  1.5f, 6.5f, 5.0f,
614 
615  7.5f, 32.5f, 25.0f,
616  15.0f, 65.0f, 50.0f,
617  7.5f, 32.5f, 25.0f,
618 
619  6.0f, 26.0f, 20.0f,
620  12.0f, 52.0f, 40.0f,
621  6.0f, 26.0f, 20.0f,
622  },
623  qScale, qOffset);
624 
625  if (dataLayout == armnn::DataLayout::NDHWC)
626  {
627  PermuteNCDHWToNDHWC(input, inputTensorInfo);
628  PermuteNCDHWToNDHWC(outputExpected, outputTensorInfo);
629  }
630 
631  return SimplePooling3dTestImpl<ArmnnType>(
632  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
633  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
634 }
635 
636 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
637 LayerTestResult<T, 5> SimpleL2Pooling3dTestCommon(
638  armnn::IWorkloadFactory& workloadFactory,
639  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
640  const armnn::ITensorHandleFactory& tensorHandleFactory,
641  const armnn::DataLayout dataLayout,
642  float qScale = 1.0f,
643  int32_t qOffset = 0)
644 {
645  armnn::Pooling3dDescriptor descriptor;
646  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
647  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 2;
648  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 2;
649  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
650  descriptor.m_DataLayout = dataLayout;
651 
652  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(1, 1, 4, 4, 4, dataLayout, ArmnnType);
653  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(1, 1, 2, 2, 2, dataLayout, ArmnnType);
654 
655  // Set quantization parameters if the requested type is a quantized type.
656  if(armnn::IsQuantizedType<T>())
657  {
658  inputTensorInfo.SetQuantizationScale(qScale);
659  inputTensorInfo.SetQuantizationOffset(qOffset);
660  outputTensorInfo.SetQuantizationScale(qScale);
661  outputTensorInfo.SetQuantizationOffset(qOffset);
662  }
663 
664  std::vector<T> inputData(
665  QuantizedVector<T>({
666  1.0f, 2.0f, 5.0f, 6.0f,
667  3.0f, 4.0f, 7.0f, 8.0f,
668  9.0f, 10.0f, 13.0f, 14.0f,
669  11.0f, 12.0f, 15.0f, 16.0f,
670 
671  17.0f, 18.0f, 21.0f, 22.0f,
672  19.0f, 20.0f, 23.0f, 24.0f,
673  25.0f, 26.0f, 29.0f, 30.0f,
674  27.0f, 28.0f, 31.0f, 32.0f,
675 
676  33.0f, 34.0f, 37.0f, 38.0f,
677  35.0f, 36.0f, 39.0f, 40.0f,
678  41.0f, 42.0f, 45.0f, 46.0f,
679  43.0f, 44.0f, 47.0f, 48.0f,
680 
681  49.0f, 50.0f, 53.0f, 54.0f,
682  51.0f, 52.0f, 55.0f, 56.0f,
683  57.0f, 58.0f, 61.0f, 62.0f,
684  59.0f, 60.0f, 63.0f, 64.0f,
685  },
686  qScale, qOffset));
687 
688  std::vector<T> outputData(
689  QuantizedVector<T>({
690  13.2476412995f, 16.5981926727f,
691  20.1866292382f, 23.9060661758f,
692 
693  43.2608367926f, 47.1963981677f,
694  51.1419592898f, 55.0953718564f,
695  },
696  qScale, qOffset));
697 
698  if (dataLayout == armnn::DataLayout::NDHWC)
699  {
700  PermuteNCDHWToNDHWC(inputData, inputTensorInfo);
701  PermuteNCDHWToNDHWC(outputData, outputTensorInfo);
702  }
703 
704  return SimplePooling3dTestImpl<ArmnnType>(
705  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
706  inputData, outputData, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
707 }
708 
709 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
710 LayerTestResult<T, 5> IgnorePaddingSimpleL2Pooling3dTestCommon(
711  armnn::IWorkloadFactory& workloadFactory,
712  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
713  const armnn::ITensorHandleFactory& tensorHandleFactory,
714  const armnn::DataLayout dataLayout,
715  float qScale = 1.0f,
716  int32_t qOffset = 0)
717 {
718  armnn::Pooling3dDescriptor descriptor;
719  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
720  descriptor.m_PoolWidth = descriptor.m_PoolHeight = descriptor.m_PoolDepth = 2;
721  descriptor.m_StrideX = descriptor.m_StrideY = descriptor.m_StrideZ = 2;
722  descriptor.m_PadLeft = 1;
723  descriptor.m_PadRight = 1;
724  descriptor.m_PadTop = 1;
725  descriptor.m_PadBottom = 1;
726  descriptor.m_PadFront = 1;
727  descriptor.m_PadBack = 1;
728  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
729  descriptor.m_DataLayout = dataLayout;
730 
731  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 4, 4, 4, dataLayout, ArmnnType);
732  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 3, 3, 3, dataLayout,ArmnnType);
733 
734  // Set quantization parameters if the requested type is a quantized type.
735  if(armnn::IsQuantizedType<T>())
736  {
737  inputTensorInfo.SetQuantizationScale(qScale);
738  inputTensorInfo.SetQuantizationOffset(qOffset);
739  outputTensorInfo.SetQuantizationScale(qScale);
740  outputTensorInfo.SetQuantizationOffset(qOffset);
741  }
742 
743  auto input = QuantizedVector<T>(
744  {
745  1.0f, 2.0f, 3.0f, 4.0f,
746  1.0f, 2.0f, 3.0f, 4.0f,
747  1.0f, 2.0f, 3.0f, 4.0f,
748  1.0f, 2.0f, 3.0f, 4.0f,
749 
750  2.0f, 3.0f, 4.0f, 5.0f,
751  2.0f, 3.0f, 4.0f, 5.0f,
752  2.0f, 3.0f, 4.0f, 5.0f,
753  2.0f, 3.0f, 4.0f, 5.0f,
754 
755  3.0f, 4.0f, 5.0f, 6.0f,
756  3.0f, 4.0f, 5.0f, 6.0f,
757  3.0f, 4.0f, 5.0f, 6.0f,
758  3.0f, 4.0f, 5.0f, 6.0f,
759 
760  4.0f, 5.0f, 6.0f, 7.0f,
761  4.0f, 5.0f, 6.0f, 7.0f,
762  4.0f, 5.0f, 6.0f, 7.0f,
763  4.0f, 5.0f, 6.0f, 7.0f,
764  },
765  qScale, qOffset);
766 
767  float v111 = float(sqrt(pow(1,2)/8.0f));
768  float v112 = float(sqrt((pow(2,2)+pow(3,2))/8.0f));
769  float v113 = float(sqrt(pow(4,2)/8));
770 
771  float v121 = float(sqrt((2*pow(1,2))/8.0f));
772  float v122 = float(sqrt((2*pow(2,2)+2*pow(3,2))/8.0f));
773  float v123 = float(sqrt((2*pow(4,2))/8.0f));
774 
775  float v131 = v111;
776  float v132 = v112;
777  float v133 = v113;
778 
779  float v211 = float(sqrt((pow(2,2)+pow(3,2))/8.0f));
780  float v212 = float(sqrt((pow(3,2)+2*pow(4,2)+pow(5,2))/8.0f));
781  float v213 = float(sqrt((pow(5,2)+pow(6,2))/8.0f));
782 
783  float v221 = float(sqrt((2*pow(2,2)+2*pow(3,2))/8.0f));
784  float v222 = float(sqrt((2*pow(3,2)+4*pow(4,2)+2*pow(5,2))/8.0f));
785  float v223 = float(sqrt((2*pow(5,2)+2*pow(6,2))/8.0f));
786 
787  float v231 = v211;
788  float v232 = v212;
789  float v233 = v213;
790 
791  float v311 = float(sqrt(pow(4,2)/8.0f));
792  float v312 = float(sqrt((pow(5,2)+pow(6,2))/8.0f));
793  float v313 = float(sqrt(pow(7,2)/8));
794 
795  float v321 = float(sqrt((2*pow(4,2))/8.0f));
796  float v322 = float(sqrt((2*pow(5,2)+2*pow(6,2))/8.0f));
797  float v323 = float(sqrt((2*pow(7,2))/8.0f));
798 
799  float v331 = v311;
800  float v332 = v312;
801  float v333 = v313;
802 
803  auto outputExpected = QuantizedVector<T>(
804  {
805  v111, v112, v113,
806  v121, v122, v123,
807  v131, v132, v133,
808 
809  v211, v212, v213,
810  v221, v222, v223,
811  v231, v232, v233,
812 
813  v311, v312, v313,
814  v321, v322, v323,
815  v331, v332, v333,
816  },
817  qScale, qOffset);
818 
819  if (dataLayout == armnn::DataLayout::NDHWC)
820  {
821  PermuteNCDHWToNDHWC(input, inputTensorInfo);
822  PermuteNCDHWToNDHWC(outputExpected, outputTensorInfo);
823  }
824 
825  return SimplePooling3dTestImpl<ArmnnType>(
826  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
827  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
828 }
829 
830 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
831 LayerTestResult<T, 5> AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTestCommon(
832  armnn::IWorkloadFactory& workloadFactory,
833  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
834  const armnn::ITensorHandleFactory& tensorHandleFactory,
835  const armnn::DataLayout dataLayout,
836  float qScale = 1.0f,
837  int32_t qOffset = 0)
838 {
839  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 1, 3, 1, dataLayout, ArmnnType);
840  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 2, 2, 1, dataLayout, ArmnnType);
841 
842  armnn::Pooling3dDescriptor descriptor;
843  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
844  descriptor.m_PoolWidth = 1;
845  descriptor.m_PoolHeight = 2;
846  descriptor.m_PoolDepth = 3;
847  descriptor.m_StrideX = 1;
848  descriptor.m_StrideY = 2;
849  descriptor.m_StrideZ = 1;
850  descriptor.m_PadLeft = 0;
851  descriptor.m_PadRight = 0;
852  descriptor.m_PadTop = 2;
853  descriptor.m_PadBottom = 0;
854  descriptor.m_PadFront = 1;
855  descriptor.m_PadBack = 2;
856  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
857  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
858  descriptor.m_DataLayout = dataLayout;
859 
860  // Construct input data.
861  auto input = QuantizedVector<T>( { 1.0f, 3.0f, 4.0f, }, qScale, qOffset);
862 
863  // These were calculated manually.
864  auto outputExpected = QuantizedVector<T>( { 0.0f, 3.0f, 0.0f, 3.0f, }, qScale, qOffset);
865 
866  if (dataLayout == armnn::DataLayout::NDHWC)
867  {
868  PermuteNCDHWToNDHWC<T>(input, inputTensorInfo);
869  PermuteNCDHWToNDHWC<T>(outputExpected, outputTensorInfo);
870  }
871 
872  return SimplePooling3dTestImpl<ArmnnType>(
873  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
874  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
875 }
876 
877 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
878 LayerTestResult<T, 5> AsymmetricNonSquareMaxPooling3dTestCommon(
879  armnn::IWorkloadFactory& workloadFactory,
880  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
881  const armnn::ITensorHandleFactory& tensorHandleFactory,
882  const armnn::DataLayout dataLayout,
883  float qScale = 1.0f,
884  int32_t qOffset = 0)
885 {
886  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 1, 3, 1, dataLayout, ArmnnType);
887  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 2, 2, 1, dataLayout, ArmnnType);
888 
889  armnn::Pooling3dDescriptor descriptor;
890  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
891  descriptor.m_PoolWidth = 1;
892  descriptor.m_PoolHeight = 2;
893  descriptor.m_PoolDepth = 3;
894  descriptor.m_StrideX = 1;
895  descriptor.m_StrideY = 2;
896  descriptor.m_StrideZ = 1;
897  descriptor.m_PadLeft = 0;
898  descriptor.m_PadRight = 0;
899  descriptor.m_PadTop = 1;
900  descriptor.m_PadBottom = 0;
901  descriptor.m_PadFront = 1;
902  descriptor.m_PadBack = 2;
903  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
904  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
905  descriptor.m_DataLayout = dataLayout;
906 
907  // Construct input data.
908  auto input = QuantizedVector<T>( { 1.0f, 3.0f, 4.0f, }, qScale, qOffset);
909 
910  // These were calculated manually.
911  auto outputExpected = QuantizedVector<T>( { 1.0f, 4.0f, 1.0f, 4.0f, }, qScale, qOffset);
912 
913  if (dataLayout == armnn::DataLayout::NDHWC)
914  {
915  PermuteNCDHWToNDHWC<T>(input, inputTensorInfo);
916  PermuteNCDHWToNDHWC<T>(outputExpected, outputTensorInfo);
917  }
918 
919  return SimplePooling3dTestImpl<ArmnnType>(
920  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
921  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
922 }
923 
924 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
925 LayerTestResult<T, 5> AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTestCommon(
926  armnn::IWorkloadFactory& workloadFactory,
927  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
928  const armnn::ITensorHandleFactory& tensorHandleFactory,
929  const armnn::DataLayout dataLayout,
930  float qScale = 1.0f,
931  int32_t qOffset = 0)
932 {
933  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 1, 3, 1, dataLayout, ArmnnType);
934  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 2, 2, 1, dataLayout, ArmnnType);
935 
936  armnn::Pooling3dDescriptor descriptor;
937  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
938  descriptor.m_PoolWidth = 1;
939  descriptor.m_PoolHeight = 2;
940  descriptor.m_PoolDepth = 3;
941  descriptor.m_StrideX = 1;
942  descriptor.m_StrideY = 2;
943  descriptor.m_StrideZ = 1;
944  descriptor.m_PadLeft = 0;
945  descriptor.m_PadRight = 0;
946  descriptor.m_PadTop = 2;
947  descriptor.m_PadBottom = 0;
948  descriptor.m_PadFront = 1;
949  descriptor.m_PadBack = 2;
950  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
951  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
952  descriptor.m_DataLayout = dataLayout;
953 
954  // Construct input data.
955  auto input = QuantizedVector<T>({ 1.0f, 3.0f, 4.0f, }, qScale, qOffset);
956 
957  // These were calculated manually.
958  auto outputExpected = QuantizedVector<T>( { 0.0f, 2.0f, 0.0f, 2.0f, }, qScale, qOffset);
959 
960  if (dataLayout == armnn::DataLayout::NDHWC)
961  {
962  PermuteNCDHWToNDHWC<T>(input, inputTensorInfo);
963  PermuteNCDHWToNDHWC<T>(outputExpected, outputTensorInfo);
964  }
965  return SimplePooling3dTestImpl<ArmnnType>(
966  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
967  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
968 }
969 
970 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
971 LayerTestResult<T, 5> AsymmetricNonSquareAveragePooling3dTestCommon(
972  armnn::IWorkloadFactory& workloadFactory,
973  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
974  const armnn::ITensorHandleFactory& tensorHandleFactory,
975  const armnn::DataLayout dataLayout,
976  float qScale = 1.0f,
977  int32_t qOffset = 0)
978 {
979  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 1, 3, 1, dataLayout, ArmnnType);
980  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 2, 2, 1, dataLayout, ArmnnType);
981 
982  armnn::Pooling3dDescriptor descriptor;
983  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
984  descriptor.m_PoolWidth = 1;
985  descriptor.m_PoolHeight = 2;
986  descriptor.m_PoolDepth = 3;
987  descriptor.m_StrideX = 1;
988  descriptor.m_StrideY = 2;
989  descriptor.m_StrideZ = 1;
990  descriptor.m_PadLeft = 0;
991  descriptor.m_PadRight = 0;
992  descriptor.m_PadTop = 1;
993  descriptor.m_PadBottom = 0;
994  descriptor.m_PadFront = 1;
995  descriptor.m_PadBack = 2;
996  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
997  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
998  descriptor.m_DataLayout = dataLayout;
999 
1000  // Construct input data.
1001  auto input = QuantizedVector<T>( { 1.0f, 3.0f, 4.0f, }, qScale, qOffset);
1002 
1003  // These were calculated manually.
1004  auto outputExpected = QuantizedVector<T>( { 1.0f, 3.5f, 1.0f, 3.5f, }, qScale, qOffset);
1005 
1006  if (dataLayout == armnn::DataLayout::NDHWC)
1007  {
1008  PermuteNCDHWToNDHWC<T>(input, inputTensorInfo);
1009  PermuteNCDHWToNDHWC<T>(outputExpected, outputTensorInfo);
1010  }
1011  return SimplePooling3dTestImpl<ArmnnType>(
1012  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
1013  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
1014 }
1015 
1016 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1017 LayerTestResult<T, 5> AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTestCommon(
1018  armnn::IWorkloadFactory& workloadFactory,
1019  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1020  const armnn::ITensorHandleFactory& tensorHandleFactory,
1021  const armnn::DataLayout dataLayout,
1022  float qScale = 1.0f,
1023  int32_t qOffset = 0)
1024 {
1025  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 1, 3, 1, dataLayout, ArmnnType);
1026  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 2, 2, 1, dataLayout, ArmnnType);
1027 
1028  armnn::Pooling3dDescriptor descriptor;
1029  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
1030  descriptor.m_PoolWidth = 1;
1031  descriptor.m_PoolHeight = 2;
1032  descriptor.m_PoolDepth = 3;
1033  descriptor.m_StrideX = 0;
1034  descriptor.m_StrideY = 2;
1035  descriptor.m_StrideZ = 1;
1036  descriptor.m_PadLeft = 0;
1037  descriptor.m_PadRight = 0;
1038  descriptor.m_PadTop = 2;
1039  descriptor.m_PadBottom = 0;
1040  descriptor.m_PadFront = 1;
1041  descriptor.m_PadBack = 2;
1042  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
1043  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
1044  descriptor.m_DataLayout = dataLayout;
1045 
1046  // Construct input data.
1047  auto input = QuantizedVector<T>( { 1.0f, 3.0f, 4.0f, }, qScale, qOffset);
1048 
1049  // These were calculated manually.
1050  auto outputExpected = QuantizedVector<T>( { 0.0f, 2.2360679775f, 0.0f, 2.2360679775f, }, qScale, qOffset);
1051 
1052  if (dataLayout == armnn::DataLayout::NDHWC)
1053  {
1054  PermuteNCDHWToNDHWC<T>(input, inputTensorInfo);
1055  PermuteNCDHWToNDHWC<T>(outputExpected, outputTensorInfo);
1056  }
1057 
1058  return SimplePooling3dTestImpl<ArmnnType>(
1059  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
1060  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
1061 }
1062 
1063 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1064 LayerTestResult<T, 5> AsymmetricNonSquareL2Pooling3dTestCommon(
1065  armnn::IWorkloadFactory& workloadFactory,
1066  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1067  const armnn::ITensorHandleFactory& tensorHandleFactory,
1068  const armnn::DataLayout dataLayout,
1069  float qScale = 1.0f,
1070  int32_t qOffset = 0)
1071 {
1072  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 1, 3, 1, dataLayout, ArmnnType);
1073  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo( 1, 1, 2, 2, 1, dataLayout, ArmnnType);
1074 
1075  armnn::Pooling3dDescriptor descriptor;
1076  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
1077  descriptor.m_PoolWidth = 1;
1078  descriptor.m_PoolHeight = 2;
1079  descriptor.m_PoolDepth = 3;
1080  descriptor.m_StrideX = 1;
1081  descriptor.m_StrideY = 2;
1082  descriptor.m_StrideZ = 1;
1083  descriptor.m_PadLeft = 0;
1084  descriptor.m_PadRight = 0;
1085  descriptor.m_PadTop = 1;
1086  descriptor.m_PadBottom = 0;
1087  descriptor.m_PadFront = 1;
1088  descriptor.m_PadBack = 2;
1089  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
1090  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
1091  descriptor.m_DataLayout = dataLayout;
1092 
1093  // Construct input data.
1094  auto input = QuantizedVector<T>( { 1.0f, 3.0f, 4.0f, }, qScale, qOffset);
1095 
1096  // These were calculated manually.
1097  auto outputExpected = QuantizedVector<T>( { 1.0f, 3.53553390593f, 1.0f, 3.53553390593f, }, qScale, qOffset);
1098 
1099  if (dataLayout == armnn::DataLayout::NDHWC)
1100  {
1101  PermuteNCDHWToNDHWC<T>(input, inputTensorInfo);
1102  PermuteNCDHWToNDHWC<T>(outputExpected, outputTensorInfo);
1103  }
1104 
1105  return SimplePooling3dTestImpl<ArmnnType>(
1106  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset,
1107  input, outputExpected, inputTensorInfo.GetShape(), outputTensorInfo.GetShape());
1108 }
1109 
1110 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1111 LayerTestResult<T, 5> ComparePooling3dTestCommon(
1112  armnn::IWorkloadFactory& workloadFactory,
1113  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1114  armnn::IWorkloadFactory& refWorkloadFactory,
1115  const armnn::ITensorHandleFactory& tensorHandleFactory,
1116  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1117  armnn::PoolingAlgorithm poolingType,
1118  const armnn::DataLayout dataLayout,
1119  float qScale = 1.0f,
1120  int32_t qOffset = 0)
1121 {
1122  IgnoreUnused(memoryManager);
1123  const unsigned int inputWidth = 16;
1124  const unsigned int inputHeight = 32;
1125  const unsigned int inputDepth = 48;
1126  const unsigned int channelCount = 2;
1127  const unsigned int batchSize = 5;
1128 
1129  const unsigned int poolSize = 3;
1130  const unsigned int strideX = 2;
1131  const unsigned int strideY = 4;
1132  const unsigned int strideZ = 6;
1133  const unsigned int padX = 0;
1134  const unsigned int padY = 0;
1135  const unsigned int padZ = 0;
1136 
1137  const unsigned int outputWidth = (inputWidth + 2 * padX + strideX - poolSize) / strideX;
1138  const unsigned int outputHeight = (inputHeight + 2 * padY + strideY - poolSize) / strideY;
1139  const unsigned int outputDepth = (inputDepth + 2 * padZ + strideZ - poolSize) / strideZ;
1140 
1141  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(batchSize, channelCount, inputDepth, inputHeight,
1142  inputWidth, dataLayout, ArmnnType);
1143  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(batchSize, channelCount, outputDepth, outputHeight,
1144  outputWidth, dataLayout, ArmnnType);
1145 
1146  // Set quantization parameters if the requested type is a quantized type.
1147  if(armnn::IsQuantizedType<T>())
1148  {
1149  inputTensorInfo.SetQuantizationScale(qScale);
1150  inputTensorInfo.SetQuantizationOffset(qOffset);
1151  outputTensorInfo.SetQuantizationScale(qScale);
1152  outputTensorInfo.SetQuantizationOffset(qOffset);
1153  }
1154 
1155  std::vector<T> input = MakeRandomTensor<T>(inputTensorInfo, 81715);
1156  std::vector<T> actualOutput(outputTensorInfo.GetNumElements());
1157  std::vector<T> expectedOutput(outputTensorInfo.GetNumElements());
1158  LayerTestResult<T, 5> comparisonResult(outputTensorInfo);
1159 
1160  std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
1161  std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
1162 
1163  armnn::Pooling3dQueueDescriptor data;
1164  armnn::WorkloadInfo info;
1165  AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
1166  AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
1167  data.m_Parameters.m_PoolType = poolingType;
1168  data.m_Parameters.m_PoolWidth = poolSize;
1169  data.m_Parameters.m_PoolHeight = poolSize;
1170  data.m_Parameters.m_PoolDepth = poolSize;
1171  data.m_Parameters.m_StrideX = strideX;
1172  data.m_Parameters.m_StrideY = strideY;
1173  data.m_Parameters.m_StrideZ = strideZ;
1174  data.m_Parameters.m_PadLeft = padX;
1175  data.m_Parameters.m_PadRight = padX;
1176  data.m_Parameters.m_PadTop = padY;
1177  data.m_Parameters.m_PadBottom = padY;
1178  data.m_Parameters.m_PadFront = padZ;
1179  data.m_Parameters.m_PadBack = padZ;
1180  data.m_Parameters.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
1181  data.m_Parameters.m_DataLayout = dataLayout;
1182 
1183  std::unique_ptr<armnn::ITensorHandle> outputHandleRef =
1184  refTensorHandleFactory.CreateTensorHandle(outputTensorInfo);
1185  std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refTensorHandleFactory.CreateTensorHandle(inputTensorInfo);
1186 
1187  // Don't execute if Pooling is not supported, as an exception will be raised.
1188  armnn::BackendId backend = workloadFactory.GetBackendId();
1189  std::string reasonIfUnsupported;
1190  armnn::LayerSupportHandle handle = armnn::GetILayerSupportByBackendId(backend);
1191  comparisonResult.m_Supported = handle.IsPooling3dSupported(inputTensorInfo,
1192  outputTensorInfo,
1193  data.m_Parameters,
1194  reasonIfUnsupported);
1195  if (!comparisonResult.m_Supported)
1196  {
1197  return comparisonResult;
1198  }
1199 
1200  armnn::Pooling3dQueueDescriptor refData = data;
1201  armnn::WorkloadInfo refInfo = info;
1202  SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
1203  SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
1204 
1205  std::unique_ptr<armnn::IWorkload> workload
1206  = workloadFactory.CreateWorkload(armnn::LayerType::Pooling3d, data, info);
1207  std::unique_ptr<armnn::IWorkload> workloadRef
1208  = refWorkloadFactory.CreateWorkload(armnn::LayerType::Pooling3d, refData, refInfo);
1209 
1210  outputHandleRef->Allocate();
1211  inputHandleRef->Allocate();
1212  inputHandle->Allocate();
1213  outputHandle->Allocate();
1214 
1215  CopyDataToITensorHandle(inputHandle.get(), input.data());
1216  CopyDataToITensorHandle(inputHandleRef.get(), input.data());
1217 
1218  workload->Execute();
1219  workloadRef->Execute();
1220 
1221  CopyDataFromITensorHandle(actualOutput.data(), outputHandle.get());
1222  CopyDataFromITensorHandle(expectedOutput.data(), outputHandleRef.get());
1223 
1224  comparisonResult.m_ActualData = actualOutput;
1225  comparisonResult.m_ExpectedData = expectedOutput;
1226 
1227  return comparisonResult;
1228 }
1229 
1230 } // anonymous namespace
1231 
1232 LayerTestResult<float, 5> SimpleMaxPooling3dSize2x2x2Stride1x1x1Test(
1233  armnn::IWorkloadFactory& workloadFactory,
1234  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1235  const armnn::ITensorHandleFactory& tensorHandleFactory,
1236  const armnn::DataLayout dataLayout)
1237 {
1238  return SimpleMaxPooling3dSize2x2x2Stride1x1x1TestCommon<armnn::DataType::Float32>(
1239  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1240 }
1241 
1242 LayerTestResult<uint8_t, 5> SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8Test(
1243  armnn::IWorkloadFactory& workloadFactory,
1244  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1245  const armnn::ITensorHandleFactory& tensorHandleFactory,
1246  const armnn::DataLayout dataLayout)
1247 {
1248  return SimpleMaxPooling3dSize2x2x2Stride1x1x1TestCommon<armnn::DataType::QAsymmU8>(
1249  workloadFactory, memoryManager, tensorHandleFactory, dataLayout, 0.1f, 128);
1250 }
1251 
1252 LayerTestResult<int16_t, 5> SimpleMaxPooling3dSize2x2x2Stride1x1x1Int16Test(
1253  armnn::IWorkloadFactory& workloadFactory,
1254  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1255  const armnn::ITensorHandleFactory& tensorHandleFactory,
1256  const armnn::DataLayout dataLayout)
1257 {
1258  return SimpleMaxPooling3dSize2x2x2Stride1x1x1TestCommon<armnn::DataType::QSymmS16>(
1259  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1260 }
1261 
1262 LayerTestResult<float, 5> SimpleMaxPooling3dTest(
1263  armnn::IWorkloadFactory& workloadFactory,
1264  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1265  const armnn::ITensorHandleFactory& tensorHandleFactory,
1266  const armnn::DataLayout dataLayout)
1267 {
1268  return SimpleMaxPooling3dTestCommon<armnn::DataType::Float32>(
1269  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1270 }
1271 
1272 LayerTestResult<uint8_t, 5> SimpleMaxPooling3dUint8Test(
1273  armnn::IWorkloadFactory& workloadFactory,
1274  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1275  const armnn::ITensorHandleFactory& tensorHandleFactory,
1276  const armnn::DataLayout dataLayout)
1277 {
1278  return SimpleMaxPooling3dTestCommon<armnn::DataType::QAsymmU8>(
1279  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1280 }
1281 
1282 LayerTestResult<int16_t, 5> SimpleMaxPooling3dInt16Test(
1283  armnn::IWorkloadFactory& workloadFactory,
1284  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1285  const armnn::ITensorHandleFactory& tensorHandleFactory,
1286  const armnn::DataLayout dataLayout)
1287 {
1288  return SimpleMaxPooling3dTestCommon<armnn::DataType::QSymmS16>(
1289  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1290 }
1291 
1292 LayerTestResult<float, 5> IgnorePaddingSimpleMaxPooling3dTest(
1293  armnn::IWorkloadFactory& workloadFactory,
1294  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1295  const armnn::ITensorHandleFactory& tensorHandleFactory,
1296  const armnn::DataLayout dataLayout)
1297 {
1298  return IgnorePaddingSimpleMaxPooling3dTestCommon<armnn::DataType::Float32>(
1299  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1300 }
1301 
1302 LayerTestResult<uint8_t, 5> IgnorePaddingSimpleMaxPooling3dUint8Test(
1303  armnn::IWorkloadFactory& workloadFactory,
1304  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1305  const armnn::ITensorHandleFactory& tensorHandleFactory,
1306  const armnn::DataLayout dataLayout)
1307 {
1308  return IgnorePaddingSimpleMaxPooling3dTestCommon<armnn::DataType::QAsymmU8>(
1309  workloadFactory, memoryManager, tensorHandleFactory,dataLayout, 1.0f, -5);
1310 }
1311 
1312 LayerTestResult<int16_t, 5> IgnorePaddingSimpleMaxPooling3dInt16Test(
1313  armnn::IWorkloadFactory& workloadFactory,
1314  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1315  const armnn::ITensorHandleFactory& tensorHandleFactory,
1316  const armnn::DataLayout dataLayout)
1317 {
1318  return IgnorePaddingSimpleMaxPooling3dTestCommon<armnn::DataType::QSymmS16>(
1319  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1320 }
1321 
1322 LayerTestResult<float, 5> SimpleAveragePooling3dTest(
1323  armnn::IWorkloadFactory& workloadFactory,
1324  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1325  const armnn::ITensorHandleFactory& tensorHandleFactory,
1326  const armnn::DataLayout dataLayout)
1327 {
1328  return SimpleAveragePooling3dTestCommon<armnn::DataType::Float32>(
1329  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1330 }
1331 
1332 LayerTestResult<uint8_t, 5> SimpleAveragePooling3dUint8Test(
1333  armnn::IWorkloadFactory& workloadFactory,
1334  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1335  const armnn::ITensorHandleFactory& tensorHandleFactory,
1336  const armnn::DataLayout dataLayout)
1337 {
1338  return SimpleAveragePooling3dTestCommon<armnn::DataType::QAsymmU8>(
1339  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1340 }
1341 
1342 LayerTestResult<int16_t, 5> SimpleAveragePooling3dInt16Test(
1343  armnn::IWorkloadFactory& workloadFactory,
1344  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1345  const armnn::ITensorHandleFactory& tensorHandleFactory,
1346  const armnn::DataLayout dataLayout)
1347 {
1348  return SimpleAveragePooling3dTestCommon<armnn::DataType::QSymmS16>(
1349  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1350 }
1351 
1352 LayerTestResult<float, 5> SimpleL2Pooling3dTest(
1353  armnn::IWorkloadFactory& workloadFactory,
1354  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1355  const armnn::ITensorHandleFactory& tensorHandleFactory,
1356  const armnn::DataLayout dataLayout)
1357 {
1358  return SimpleL2Pooling3dTestCommon<armnn::DataType::Float32>(
1359  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1360 }
1361 
1362 LayerTestResult<uint8_t, 5> SimpleL2Pooling3dUint8Test(
1363  armnn::IWorkloadFactory& workloadFactory,
1364  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1365  const armnn::ITensorHandleFactory& tensorHandleFactory,
1366  const armnn::DataLayout dataLayout)
1367 {
1368  return SimpleL2Pooling3dTestCommon<armnn::DataType::QAsymmU8>(
1369  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1370 }
1371 
1372 LayerTestResult<int16_t, 5> SimpleL2Pooling3dInt16Test(
1373  armnn::IWorkloadFactory& workloadFactory,
1374  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1375  const armnn::ITensorHandleFactory& tensorHandleFactory,
1376  const armnn::DataLayout dataLayout)
1377 {
1378  return SimpleL2Pooling3dTestCommon<armnn::DataType::QSymmS16>(
1379  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1380 }
1381 
1382 LayerTestResult<float, 5> LargeTensorsAveragePooling3dTest(
1383  armnn::IWorkloadFactory& workloadFactory,
1384  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1385  const armnn::ITensorHandleFactory& tensorHandleFactory,
1386  const armnn::DataLayout dataLayout)
1387 {
1388  return LargeTensorsAveragePooling3dTestCommon<armnn::DataType::Float32>(
1389  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1390 }
1391 
1392 LayerTestResult<uint8_t, 5> LargeTensorsAveragePooling3dUint8Test(
1393  armnn::IWorkloadFactory& workloadFactory,
1394  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1395  const armnn::ITensorHandleFactory& tensorHandleFactory,
1396  const armnn::DataLayout dataLayout)
1397 {
1398  return LargeTensorsAveragePooling3dTestCommon<armnn::DataType::QAsymmU8>(
1399  workloadFactory, memoryManager, tensorHandleFactory, dataLayout, 0.5, -1);
1400 }
1401 
1402 LayerTestResult<int16_t, 5> LargeTensorsAveragePooling3dInt16Test(
1403  armnn::IWorkloadFactory& workloadFactory,
1404  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1405  const armnn::ITensorHandleFactory& tensorHandleFactory,
1406  const armnn::DataLayout dataLayout)
1407 {
1408  return LargeTensorsAveragePooling3dTestCommon<armnn::DataType::QSymmS16>(
1409  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1410 }
1411 
1412 LayerTestResult<float, 5> IgnorePaddingSimpleAveragePooling3dTest(
1413  armnn::IWorkloadFactory& workloadFactory,
1414  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1415  const armnn::ITensorHandleFactory& tensorHandleFactory,
1416  const armnn::DataLayout dataLayout)
1417 {
1418  return IgnorePaddingSimpleAveragePooling3dTestCommon<armnn::DataType::Float32>(
1419  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1420 }
1421 
1422 LayerTestResult<uint8_t, 5> IgnorePaddingSimpleAveragePooling3dUint8Test(
1423  armnn::IWorkloadFactory& workloadFactory,
1424  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1425  const armnn::ITensorHandleFactory& tensorHandleFactory,
1426  const armnn::DataLayout dataLayout)
1427 {
1428  return IgnorePaddingSimpleAveragePooling3dTestCommon<armnn::DataType::QAsymmU8>(
1429  workloadFactory, memoryManager, tensorHandleFactory, dataLayout, 1.0f, -5);
1430 }
1431 
1432 LayerTestResult<int16_t, 5> IgnorePaddingSimpleAveragePooling3dInt16Test(
1433  armnn::IWorkloadFactory& workloadFactory,
1434  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1435  const armnn::ITensorHandleFactory& tensorHandleFactory,
1436  const armnn::DataLayout dataLayout)
1437 {
1438  return IgnorePaddingSimpleAveragePooling3dTestCommon<armnn::DataType::QSymmS16>(
1439  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1440 }
1441 
1442 LayerTestResult<float, 5> IgnorePaddingSimpleL2Pooling3dTest(
1443  armnn::IWorkloadFactory& workloadFactory,
1444  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1445  const armnn::ITensorHandleFactory& tensorHandleFactory,
1446  const armnn::DataLayout dataLayout)
1447 {
1448  return IgnorePaddingSimpleL2Pooling3dTestCommon<armnn::DataType::Float32>(
1449  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1450 }
1451 
1452 LayerTestResult<uint8_t, 5> IgnorePaddingSimpleL2Pooling3dUint8Test(
1453  armnn::IWorkloadFactory& workloadFactory,
1454  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1455  const armnn::ITensorHandleFactory& tensorHandleFactory,
1456  const armnn::DataLayout dataLayout)
1457 {
1458  return IgnorePaddingSimpleL2Pooling3dTestCommon<armnn::DataType::QAsymmU8>(
1459  workloadFactory, memoryManager, tensorHandleFactory, dataLayout, 1.0f, -5);
1460 }
1461 
1462 LayerTestResult<int16_t, 5> IgnorePaddingSimpleL2Pooling3dInt16Test(
1463  armnn::IWorkloadFactory& workloadFactory,
1464  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1465  const armnn::ITensorHandleFactory& tensorHandleFactory,
1466  const armnn::DataLayout dataLayout)
1467 {
1468  return IgnorePaddingSimpleL2Pooling3dTestCommon<armnn::DataType::QSymmS16>(
1469  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1470 }
1471 
1472 LayerTestResult<float, 5> AsymmetricNonSquareMaxPooling3dTest(
1473  armnn::IWorkloadFactory& workloadFactory,
1474  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1475  const armnn::ITensorHandleFactory& tensorHandleFactory,
1476  const armnn::DataLayout dataLayout)
1477 {
1478  return AsymmetricNonSquareMaxPooling3dTestCommon<armnn::DataType::Float32>(
1479  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1480 }
1481 
1482 LayerTestResult<uint8_t, 5> AsymmetricNonSquareMaxPooling3dUint8Test(
1483  armnn::IWorkloadFactory& workloadFactory,
1484  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1485  const armnn::ITensorHandleFactory& tensorHandleFactory,
1486  const armnn::DataLayout dataLayout)
1487 {
1488  return AsymmetricNonSquareMaxPooling3dTestCommon<armnn::DataType::QAsymmU8>(
1489  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1490 }
1491 
1492 LayerTestResult<int16_t, 5> AsymmetricNonSquareMaxPooling3dInt16Test(
1493  armnn::IWorkloadFactory& workloadFactory,
1494  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1495  const armnn::ITensorHandleFactory& tensorHandleFactory,
1496  const armnn::DataLayout dataLayout)
1497 {
1498  return AsymmetricNonSquareMaxPooling3dTestCommon<armnn::DataType::QSymmS16>(
1499  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1500 }
1501 
1502 LayerTestResult<float, 5> AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTest(
1503  armnn::IWorkloadFactory& workloadFactory,
1504  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1505  const armnn::ITensorHandleFactory& tensorHandleFactory,
1506  const armnn::DataLayout dataLayout)
1507 {
1508  return AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::Float32>(
1509  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1510 }
1511 
1512 LayerTestResult<uint8_t, 5> AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8Test(
1513  armnn::IWorkloadFactory& workloadFactory,
1514  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1515  const armnn::ITensorHandleFactory& tensorHandleFactory,
1516  const armnn::DataLayout dataLayout)
1517 {
1518  return AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::QAsymmU8>(
1519  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1520 }
1521 
1522 LayerTestResult<int16_t, 5> AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolInt16Test(
1523  armnn::IWorkloadFactory& workloadFactory,
1524  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1525  const armnn::ITensorHandleFactory& tensorHandleFactory,
1526  const armnn::DataLayout dataLayout)
1527 {
1528  return AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::QSymmS16>(
1529  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1530 }
1531 
1532 LayerTestResult<float, 5> AsymmetricNonSquareAveragePooling3dTest(
1533  armnn::IWorkloadFactory& workloadFactory,
1534  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1535  const armnn::ITensorHandleFactory& tensorHandleFactory,
1536  const armnn::DataLayout dataLayout)
1537 {
1538  return AsymmetricNonSquareAveragePooling3dTestCommon<armnn::DataType::Float32>(
1539  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1540 }
1541 
1542 LayerTestResult<uint8_t, 5> AsymmetricNonSquareAveragePooling3dUint8Test(
1543  armnn::IWorkloadFactory& workloadFactory,
1544  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1545  const armnn::ITensorHandleFactory& tensorHandleFactory,
1546  const armnn::DataLayout dataLayout)
1547 {
1548  return AsymmetricNonSquareAveragePooling3dTestCommon<armnn::DataType::QAsymmU8>(
1549  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1550 }
1551 
1552 LayerTestResult<int16_t, 5> AsymmetricNonSquareAveragePooling3dInt16Test(
1553  armnn::IWorkloadFactory& workloadFactory,
1554  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1555  const armnn::ITensorHandleFactory& tensorHandleFactory,
1556  const armnn::DataLayout dataLayout)
1557 {
1558  return AsymmetricNonSquareAveragePooling3dTestCommon<armnn::DataType::QSymmS16>(
1559  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1560 }
1561 
1562 LayerTestResult<float, 5> AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTest(
1563  armnn::IWorkloadFactory& workloadFactory,
1564  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1565  const armnn::ITensorHandleFactory& tensorHandleFactory,
1566  const armnn::DataLayout dataLayout)
1567 {
1568  return AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::Float32>(
1569  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1570 }
1571 
1572 LayerTestResult<uint8_t, 5> AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8Test(
1573  armnn::IWorkloadFactory& workloadFactory,
1574  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1575  const armnn::ITensorHandleFactory& tensorHandleFactory,
1576  const armnn::DataLayout dataLayout)
1577 {
1578  return AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::QAsymmU8>(
1579  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1580 }
1581 
1582 LayerTestResult<int16_t, 5> AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolInt16Test(
1583  armnn::IWorkloadFactory& workloadFactory,
1584  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1585  const armnn::ITensorHandleFactory& tensorHandleFactory,
1586  const armnn::DataLayout dataLayout)
1587 {
1588  return AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::QSymmS16>(
1589  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1590 }
1591 
1592 LayerTestResult<float, 5> AsymmetricNonSquareL2Pooling3dTest(
1593  armnn::IWorkloadFactory& workloadFactory,
1594  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1595  const armnn::ITensorHandleFactory& tensorHandleFactory,
1596  const armnn::DataLayout dataLayout)
1597 {
1598  return AsymmetricNonSquareL2Pooling3dTestCommon<armnn::DataType::Float32>(
1599  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1600 }
1601 
1602 LayerTestResult<uint8_t, 5> AsymmetricNonSquareL2Pooling3dUint8Test(
1603  armnn::IWorkloadFactory& workloadFactory,
1604  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1605  const armnn::ITensorHandleFactory& tensorHandleFactory,
1606  const armnn::DataLayout dataLayout)
1607 {
1608  return AsymmetricNonSquareL2Pooling3dTestCommon<armnn::DataType::QAsymmU8>(
1609  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1610 }
1611 
1612 LayerTestResult<int16_t, 5> AsymmetricNonSquareL2Pooling3dInt16Test(
1613  armnn::IWorkloadFactory& workloadFactory,
1614  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1615  const armnn::ITensorHandleFactory& tensorHandleFactory,
1616  const armnn::DataLayout dataLayout)
1617 {
1618  return AsymmetricNonSquareL2Pooling3dTestCommon<armnn::DataType::QSymmS16>(
1619  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1620 }
1621 
1622 LayerTestResult<float, 5> AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTest(
1623  armnn::IWorkloadFactory& workloadFactory,
1624  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1625  const armnn::ITensorHandleFactory& tensorHandleFactory,
1626  const armnn::DataLayout dataLayout)
1627 {
1628  return AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::Float32>(
1629  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1630 }
1631 
1632 LayerTestResult<uint8_t, 5> AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8Test(
1633  armnn::IWorkloadFactory& workloadFactory,
1634  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1635  const armnn::ITensorHandleFactory& tensorHandleFactory,
1636  const armnn::DataLayout dataLayout)
1637 {
1638  return AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::QAsymmU8>(
1639  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1640 }
1641 
1642 LayerTestResult<int16_t, 5> AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolInt16Test(
1643  armnn::IWorkloadFactory& workloadFactory,
1644  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1645  const armnn::ITensorHandleFactory& tensorHandleFactory,
1646  const armnn::DataLayout dataLayout)
1647 {
1648  return AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTestCommon<armnn::DataType::QSymmS16>(
1649  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1650 }
1651 
1652 LayerTestResult<float, 5> ComparePooling3dTest(
1653  armnn::IWorkloadFactory& workloadFactory,
1654  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1655  armnn::IWorkloadFactory& refWorkloadFactory,
1656  const armnn::ITensorHandleFactory& tensorHandleFactory,
1657  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1658  armnn::PoolingAlgorithm poolingType,
1659  const armnn::DataLayout dataLayout)
1660 {
1661  return ComparePooling3dTestCommon<armnn::DataType::Float32>(
1662  workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory,
1663  poolingType, dataLayout);
1664 }
1665 
1666 LayerTestResult<uint8_t, 5> ComparePooling3dUint8Test(
1667  armnn::IWorkloadFactory& workloadFactory,
1668  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1669  armnn::IWorkloadFactory& refWorkloadFactory,
1670  const armnn::ITensorHandleFactory& tensorHandleFactory,
1671  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1672  armnn::PoolingAlgorithm poolingType,
1673  const armnn::DataLayout dataLayout)
1674 {
1675  return ComparePooling3dTestCommon<armnn::DataType::QAsymmU8>(
1676  workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory,
1677  poolingType, dataLayout, 0.1f, 128);
1678 }
1679 
1680 LayerTestResult<int16_t, 5> ComparePooling3dInt16Test(
1681  armnn::IWorkloadFactory& workloadFactory,
1682  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1683  armnn::IWorkloadFactory& refWorkloadFactory,
1684  const armnn::ITensorHandleFactory& tensorHandleFactory,
1685  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1686  armnn::PoolingAlgorithm poolingType,
1687  const armnn::DataLayout dataLayout)
1688 {
1689  return ComparePooling3dTestCommon<armnn::DataType::QSymmS16>(
1690  workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory,
1691  poolingType, dataLayout);
1692 }
armnn::TensorShape::GetNumElements
unsigned int GetNumElements() const
Function that calculates the tensor elements by multiplying all dimension size which are Specified...
Definition: Tensor.cpp:181
armnn::Pooling3dDescriptor::m_PoolType
PoolingAlgorithm m_PoolType
The pooling algorithm to use (Max. Average, L2).
Definition: Descriptors.hpp:434
IgnoreUnused.hpp
armnn::IWorkloadFactory::GetBackendId
virtual const BackendId & GetBackendId() const =0
AsymmetricNonSquareAveragePooling3dUint8Test
LayerTestResult< uint8_t, 5 > AsymmetricNonSquareAveragePooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1542
DataLayoutIndexed.hpp
LargeTensorsAveragePooling3dTest
LayerTestResult< float, 5 > LargeTensorsAveragePooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1382
SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8Test
LayerTestResult< uint8_t, 5 > SimpleMaxPooling3dSize2x2x2Stride1x1x1Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1242
ComparePooling3dInt16Test
LayerTestResult< int16_t, 5 > ComparePooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::PoolingAlgorithm poolingType, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1680
armnn::DataLayout
DataLayout
Definition: Types.hpp:62
armnnUtils::DataLayoutIndexed::GetWidthIndex
unsigned int GetWidthIndex() const
Definition: DataLayoutIndexed.hpp:25
armnn::Pooling3dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:456
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:191
armnn::Pooling3dDescriptor::m_PoolWidth
uint32_t m_PoolWidth
Pooling width value.
Definition: Descriptors.hpp:448
armnn::Pooling3dDescriptor::m_PoolDepth
uint32_t m_PoolDepth
Pooling depth value.
Definition: Descriptors.hpp:452
AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTest
LayerTestResult< float, 5 > AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1562
SimpleAveragePooling3dInt16Test
LayerTestResult< int16_t, 5 > SimpleAveragePooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1342
IgnorePaddingSimpleL2Pooling3dUint8Test
LayerTestResult< uint8_t, 5 > IgnorePaddingSimpleL2Pooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1452
AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolInt16Test
LayerTestResult< int16_t, 5 > AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1522
QuantizeHelper.hpp
IgnorePaddingSimpleL2Pooling3dTest
LayerTestResult< float, 5 > IgnorePaddingSimpleL2Pooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1442
armnn::PaddingMethod::Exclude
The padding fields don&#39;t count and are ignored.
ComparePooling3dTest
LayerTestResult< float, 5 > ComparePooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::PoolingAlgorithm poolingType, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1652
AsymmetricNonSquareAveragePooling3dInt16Test
LayerTestResult< int16_t, 5 > AsymmetricNonSquareAveragePooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1552
armnn::LayerSupportHandle::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string &> reasonIfUnsupported=EmptyOptional())
Definition: BackendHelper.cpp:1037
IgnorePaddingSimpleMaxPooling3dUint8Test
LayerTestResult< uint8_t, 5 > IgnorePaddingSimpleMaxPooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1302
AsymmetricNonSquareL2Pooling3dInt16Test
LayerTestResult< int16_t, 5 > AsymmetricNonSquareL2Pooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1612
armnn::Pooling3dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:438
armnnUtils::DataLayoutIndexed::GetDepthIndex
unsigned int GetDepthIndex() const
Definition: DataLayoutIndexed.hpp:26
ResolveType.hpp
IgnorePaddingSimpleAveragePooling3dInt16Test
LayerTestResult< int16_t, 5 > IgnorePaddingSimpleAveragePooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1432
AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTest
LayerTestResult< float, 5 > AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1622
AsymmetricNonSquareL2Pooling3dUint8Test
LayerTestResult< uint8_t, 5 > AsymmetricNonSquareL2Pooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1602
ComparePooling3dUint8Test
LayerTestResult< uint8_t, 5 > ComparePooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::PoolingAlgorithm poolingType, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1666
BackendHelper.hpp
armnn::Pooling3dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCDHW, NDHWC).
Definition: Descriptors.hpp:464
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
Pooling3dTestImpl.hpp
armnn::Pooling3dDescriptor::m_PadFront
uint32_t m_PadFront
Padding front value in the depth dimension.
Definition: Descriptors.hpp:444
armnn::PoolingAlgorithm
PoolingAlgorithm
Definition: Types.hpp:136
armnn::Pooling3dDescriptor::m_PoolHeight
uint32_t m_PoolHeight
Pooling height value.
Definition: Descriptors.hpp:450
armnnUtils::DataLayoutIndexed::GetHeightIndex
unsigned int GetHeightIndex() const
Definition: DataLayoutIndexed.hpp:24
NumericCast.hpp
IgnorePaddingSimpleL2Pooling3dInt16Test
LayerTestResult< int16_t, 5 > IgnorePaddingSimpleL2Pooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1462
armnnUtils::Permute
void Permute(const armnn::TensorShape &dstShape, const armnn::PermutationVector &mappings, const void *src, void *dst, size_t dataTypeSize)
Definition: Permute.cpp:131
AsymmetricNonSquareMaxPooling3dUint8Test
LayerTestResult< uint8_t, 5 > AsymmetricNonSquareMaxPooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1482
armnn::Pooling3dDescriptor::m_PadBack
uint32_t m_PadBack
Padding back value in the depth dimension.
Definition: Descriptors.hpp:446
AsymmetricNonSquareMaxPooling3dTest
LayerTestResult< float, 5 > AsymmetricNonSquareMaxPooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1472
SimpleL2Pooling3dTest
LayerTestResult< float, 5 > SimpleL2Pooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1352
IgnorePaddingSimpleMaxPooling3dTest
LayerTestResult< float, 5 > IgnorePaddingSimpleMaxPooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1292
Permute.hpp
AsymmetricNonSquareL2Pooling3dTest
LayerTestResult< float, 5 > AsymmetricNonSquareL2Pooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1592
armnn::IBackendInternal::IMemoryManagerSharedPtr
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
Definition: IBackendInternal.hpp:97
armnnUtils::DataLayoutIndexed
Provides access to the appropriate indexes for Channels, Height and Width based on DataLayout...
Definition: DataLayoutIndexed.hpp:17
armnn::Pooling3dDescriptor::m_OutputShapeRounding
OutputShapeRounding m_OutputShapeRounding
The rounding method for the output shape. (Floor, Ceiling).
Definition: Descriptors.hpp:460
armnn::Pooling3dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:442
CopyDataFromITensorHandle
void CopyDataFromITensorHandle(void *mem, const armnn::ITensorHandle *tensorHandle)
Definition: TensorCopyUtils.cpp:14
LargeTensorsAveragePooling3dUint8Test
LayerTestResult< uint8_t, 5 > LargeTensorsAveragePooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1392
IgnorePaddingSimpleMaxPooling3dInt16Test
LayerTestResult< int16_t, 5 > IgnorePaddingSimpleMaxPooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1312
AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolInt16Test
LayerTestResult< int16_t, 5 > AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1642
armnn::TensorInfo::SetQuantizationScale
void SetQuantizationScale(float scale)
Definition: Tensor.cpp:473
AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8Test
LayerTestResult< uint8_t, 5 > AsymmetricNonSquareL2Pooling3dWithPaddingOnlyPoolUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1632
IgnorePaddingSimpleAveragePooling3dTest
LayerTestResult< float, 5 > IgnorePaddingSimpleAveragePooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1412
AsymmetricNonSquareMaxPooling3dInt16Test
LayerTestResult< int16_t, 5 > AsymmetricNonSquareMaxPooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1492
SimpleAveragePooling3dTest
LayerTestResult< float, 5 > SimpleAveragePooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1322
IgnorePaddingSimpleAveragePooling3dUint8Test
LayerTestResult< uint8_t, 5 > IgnorePaddingSimpleAveragePooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1422
SimpleMaxPooling3dUint8Test
LayerTestResult< uint8_t, 5 > SimpleMaxPooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1272
armnn::Pooling3dDescriptor
A Pooling3dDescriptor for the Pooling3dLayer.
Definition: Descriptors.hpp:392
armnn::Pooling3dDescriptor::m_StrideZ
uint32_t m_StrideZ
Stride value when proceeding through input for the depth dimension.
Definition: Descriptors.hpp:458
SimpleMaxPooling3dInt16Test
LayerTestResult< int16_t, 5 > SimpleMaxPooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1282
TensorUtils.hpp
armnn::Pooling3dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:436
armnn::PaddingMethod::IgnoreValue
The padding fields count, but are ignored.
CopyDataToITensorHandle
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
Definition: TensorCopyUtils.cpp:9
armnn::Pooling3dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:440
SimpleL2Pooling3dInt16Test
LayerTestResult< int16_t, 5 > SimpleL2Pooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1372
SimpleMaxPooling3dSize2x2x2Stride1x1x1Test
LayerTestResult< float, 5 > SimpleMaxPooling3dSize2x2x2Stride1x1x1Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1232
AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolInt16Test
LayerTestResult< int16_t, 5 > AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1582
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:35
armnnUtils::GetTensorInfo
armnn::TensorInfo GetTensorInfo(unsigned int numberOfBatches, unsigned int numberOfChannels, unsigned int height, unsigned int width, const armnn::DataLayout dataLayout, const armnn::DataType dataType)
Definition: TensorUtils.cpp:38
SimpleL2Pooling3dUint8Test
LayerTestResult< uint8_t, 5 > SimpleL2Pooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1362
armnn::WorkloadInfo
Contains information about TensorInfos of a layer.
Definition: WorkloadInfo.hpp:16
AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8Test
LayerTestResult< uint8_t, 5 > AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1512
armnn::TensorInfo::SetQuantizationOffset
void SetQuantizationOffset(int32_t offset)
Definition: Tensor.cpp:489
SimpleMaxPooling3dTest
LayerTestResult< float, 5 > SimpleMaxPooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1262
armnn::GetILayerSupportByBackendId
LayerSupportHandle GetILayerSupportByBackendId(const armnn::BackendId &backend)
Convenience function to retrieve the ILayerSupportHandle for a backend.
Definition: BackendHelper.cpp:16
armnn::Pooling3dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:454
SimpleAveragePooling3dUint8Test
LayerTestResult< uint8_t, 5 > SimpleAveragePooling3dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1332
armnn::Pooling3dDescriptor::m_PaddingMethod
PaddingMethod m_PaddingMethod
The padding method to be used. (Exclude, IgnoreValue).
Definition: Descriptors.hpp:462
AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8Test
LayerTestResult< uint8_t, 5 > AsymmetricNonSquareAveragePooling3dWithPaddingOnlyPoolUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1572
armnn::IWorkloadFactory::CreateWorkload
virtual std::unique_ptr< IWorkload > CreateWorkload(LayerType type, const QueueDescriptor &descriptor, const WorkloadInfo &info) const
Definition: WorkloadFactory.cpp:1559
armnnUtils::DataLayoutIndexed::GetChannelsIndex
unsigned int GetChannelsIndex() const
Definition: DataLayoutIndexed.hpp:23
SimpleMaxPooling3dSize2x2x2Stride1x1x1Int16Test
LayerTestResult< int16_t, 5 > SimpleMaxPooling3dSize2x2x2Stride1x1x1Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1252
armnn::ITensorHandleFactory::CreateTensorHandle
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo) const =0
armnn::TensorInfo::GetNumElements
unsigned int GetNumElements() const
Definition: Tensor.hpp:196
AsymmetricNonSquareAveragePooling3dTest
LayerTestResult< float, 5 > AsymmetricNonSquareAveragePooling3dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1532
LargeTensorsAveragePooling3dInt16Test
LayerTestResult< int16_t, 5 > LargeTensorsAveragePooling3dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1402
AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTest
LayerTestResult< float, 5 > AsymmetricNonSquareMaxPooling3dWithPaddingOnlyPoolTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling3dTestImpl.cpp:1502