src/backends/backendsCommon/test/layerTests/DepthToSpaceTestImpl.cpp

   1 //
   2 // Copyright © 2019 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include "DepthToSpaceTestImpl.hpp"
   7
   8 #include <QuantizeHelper.hpp>
   9
  10 #include <armnn/ArmNN.hpp>
  11
  12 #include <backendsCommon/test/DataLayoutUtils.hpp>
  13 #include <backendsCommon/test/TensorCopyUtils.hpp>
  14 #include <backendsCommon/test/WorkloadTestUtils.hpp>
  15
  16 #include <test/TensorHelpers.hpp>
  17
  18 namespace
  19 {
  20
  21 template<typename T>
  22 LayerTestResult<T, 4> DepthToSpaceTestImpl(
  23     armnn::IWorkloadFactory& workloadFactory,
  24     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  25     armnn::TensorInfo& inputInfo,
  26     armnn::TensorInfo& outputInfo,
  27     std::vector<float>& inputData,
  28     std::vector<float>& expectedOutputData,
  29     armnn::DepthToSpaceQueueDescriptor descriptor,
  30     const float qScale = 1.0f,
  31     const int32_t qOffset = 0)
  32 {
  33     boost::ignore_unused(memoryManager);
  34     if (descriptor.m_Parameters.m_DataLayout == armnn::DataLayout::NCHW)
  35     {
  36         PermuteTensorNhwcToNchw<float>(inputInfo, inputData);
  37         PermuteTensorNhwcToNchw<float>(outputInfo, expectedOutputData);
  38     }
  39
  40     if(armnn::IsQuantizedType<T>())
  41     {
  42         inputInfo.SetQuantizationScale(qScale);
  43         inputInfo.SetQuantizationOffset(qOffset);
  44         outputInfo.SetQuantizationScale(qScale);
  45         outputInfo.SetQuantizationOffset(qOffset);
  46     }
  47
  48     boost::multi_array<T, 4> input =
  49         MakeTensor<T, 4>(inputInfo, armnnUtils::QuantizedVector<T>(inputData, qScale, qOffset));
  50
  51     LayerTestResult<T, 4> result(outputInfo);
  52     result.outputExpected =
  53         MakeTensor<T, 4>(outputInfo, armnnUtils::QuantizedVector<T>(expectedOutputData, qScale, qOffset));
  54
  55     std::unique_ptr<armnn::ITensorHandle> inputHandle  = workloadFactory.CreateTensorHandle(inputInfo);
  56     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputInfo);
  57
  58     armnn::WorkloadInfo info;
  59     AddInputToWorkload(descriptor, info, inputInfo, inputHandle.get());
  60     AddOutputToWorkload(descriptor, info, outputInfo, outputHandle.get());
  61
  62     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateDepthToSpace(descriptor, info);
  63
  64     inputHandle->Allocate();
  65     outputHandle->Allocate();
  66
  67     CopyDataToITensorHandle(inputHandle.get(), input.origin());
  68
  69     workload->Execute();
  70
  71     CopyDataFromITensorHandle(result.output.origin(), outputHandle.get());
  72     return result;
  73 }
  74
  75 } // anonymous namespace
  76
  77 template<armnn::DataType ArmnnType, typename T>
  78 LayerTestResult<T, 4> DepthToSpaceTest1(
  79     armnn::IWorkloadFactory& workloadFactory,
  80     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  81     armnn::DataLayout dataLayout)
  82 {
  83     unsigned int inputShape[]  = { 1, 1, 1, 8 };
  84     unsigned int outputShape[] = { 1, 2, 2, 2 };
  85
  86     // in:
  87     // [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
  88     //
  89     // out:
  90     // [[[[1, 2, 3], [4, 5, 6]],
  91     //   [[7, 8, 9], [10, 11, 12]]]]
  92
  93     std::vector<float> input          = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
  94     std::vector<float> expectedOutput = input;
  95
  96     armnn::DepthToSpaceQueueDescriptor desc;
  97     desc.m_Parameters.m_DataLayout = dataLayout;
  98     desc.m_Parameters.m_BlockSize  = 2;
  99
 100     armnn::TensorInfo inputInfo(4, inputShape, ArmnnType);
 101     armnn::TensorInfo outputInfo(4, outputShape, ArmnnType);
 102
 103     return DepthToSpaceTestImpl<T>(workloadFactory, memoryManager, inputInfo, outputInfo, input, expectedOutput, desc);
 104 }
 105
 106 template<armnn::DataType ArmnnType, typename T>
 107 LayerTestResult<T, 4> DepthToSpaceTest2(
 108     armnn::IWorkloadFactory& workloadFactory,
 109     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 110     armnn::DataLayout dataLayout)
 111 {
 112     unsigned int inputShape[]  = { 1, 2, 2, 4 };
 113     unsigned int outputShape[] = { 1, 4, 4, 1 };
 114
 115     // in:
 116     // [[[[1, 2, 3, 4],
 117     //   [5, 6, 7, 8]],
 118     //  [[9, 10, 11, 12],
 119     //   [13, 14, 15, 16]]]]
 120     //
 121     // out:
 122     // [[[ [1],   [2],  [5],  [6]],
 123     //  [ [3],   [4],  [7],  [8]],
 124     //  [ [9],  [10], [13],  [14]],
 125     //  [ [11], [12], [15],  [16]]]]
 126
 127     std::vector<float> input =
 128     {
 129         1.f,  2.f,  3.f,  4.f,
 130
 131         5.f,  6.f,  7.f,  8.f,
 132
 133         9.f, 10.f, 11.f, 12.f,
 134
 135         13.f, 14.f, 15.f, 16.f
 136     };
 137
 138     std::vector<float> expectedOutput
 139     {
 140          1.f,   2.f,   5.f,   6.f,
 141          3.f,   4.f,   7.f,   8.f,
 142          9.f,  10.f,  13.f,  14.f,
 143         11.f,  12.f,  15.f,  16.f
 144     };
 145
 146     armnn::DepthToSpaceQueueDescriptor desc;
 147     desc.m_Parameters.m_DataLayout = dataLayout;
 148     desc.m_Parameters.m_BlockSize  = 2;
 149
 150     armnn::TensorInfo inputInfo(4, inputShape, ArmnnType);
 151     armnn::TensorInfo outputInfo(4, outputShape, ArmnnType);
 152
 153     return DepthToSpaceTestImpl<T>(workloadFactory, memoryManager, inputInfo, outputInfo, input, expectedOutput, desc);
 154 }
 155
 156 template<armnn::DataType ArmnnType, typename T>
 157 LayerTestResult<T, 4> DepthToSpaceTest3(
 158     armnn::IWorkloadFactory& workloadFactory,
 159     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 160     armnn::DataLayout dataLayout)
 161 {
 162     unsigned int inputShape[]  = { 2, 1, 1, 4 };
 163     unsigned int outputShape[] = { 2, 2, 2, 1 };
 164
 165     std::vector<float> input =
 166     {
 167         1.f, 2.f, 3.f, 4.f, // batch 0
 168         5.f, 6.f, 7.f, 8.f  // batch 1
 169     };
 170
 171     std::vector<float> expectedOutput = input;
 172
 173     armnn::DepthToSpaceQueueDescriptor desc;
 174     desc.m_Parameters.m_DataLayout = dataLayout;
 175     desc.m_Parameters.m_BlockSize  = 2;
 176
 177     armnn::TensorInfo inputInfo(4, inputShape, ArmnnType);
 178     armnn::TensorInfo outputInfo(4, outputShape, ArmnnType);
 179
 180     return DepthToSpaceTestImpl<T>(workloadFactory, memoryManager, inputInfo, outputInfo, input, expectedOutput, desc);
 181 }
 182
 183 template<armnn::DataType ArmnnType, typename T>
 184 LayerTestResult<T, 4> DepthToSpaceTest4(
 185     armnn::IWorkloadFactory& workloadFactory,
 186     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 187     armnn::DataLayout dataLayout)
 188 {
 189     unsigned int inputShape[]  = { 2, 2, 2, 4 };
 190     unsigned int outputShape[] = { 2, 4, 4, 1 };
 191
 192     std::vector<float> input =
 193     {
 194         1.f,  2.f,  3.f,  4.f,
 195
 196         5.f,  6.f,  7.f,  8.f,
 197
 198         9.f, 10.f, 11.f, 12.f,
 199
 200         13.f, 14.f, 15.f, 16.f,
 201
 202
 203         17.f, 18.f, 19.f, 20.f,
 204
 205         21.f, 22.f, 23.f, 24.f,
 206
 207         25.f, 26.f, 27.f, 28.f,
 208
 209         29.f, 30.f, 31.f, 32.f
 210     };
 211
 212     std::vector<float> expectedOutput
 213     {
 214          1.f,   2.f,   5.f,   6.f,
 215          3.f,   4.f,   7.f,   8.f,
 216          9.f,  10.f,  13.f,  14.f,
 217         11.f,  12.f,  15.f,  16.f,
 218
 219
 220         17.f,  18.f,  21.f,  22.f,
 221         19.f,  20.f,  23.f,  24.f,
 222         25.f,  26.f,  29.f,  30.f,
 223         27.f,  28.f,  31.f,  32.f
 224     };
 225
 226     armnn::DepthToSpaceQueueDescriptor desc;
 227     desc.m_Parameters.m_DataLayout = dataLayout;
 228     desc.m_Parameters.m_BlockSize  = 2;
 229
 230     armnn::TensorInfo inputInfo(4, inputShape, ArmnnType);
 231     armnn::TensorInfo outputInfo(4, outputShape, ArmnnType);
 232
 233     return DepthToSpaceTestImpl<T>(workloadFactory, memoryManager, inputInfo, outputInfo, input, expectedOutput, desc);
 234 }
 235
 236 // Float32
 237 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 238 DepthToSpaceTest1<armnn::DataType::Float32>(
 239     armnn::IWorkloadFactory& workloadFactory,
 240     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 241     armnn::DataLayout dataLayout);
 242
 243 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 244 DepthToSpaceTest2<armnn::DataType::Float32>(
 245     armnn::IWorkloadFactory& workloadFactory,
 246     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 247     armnn::DataLayout dataLayout);
 248
 249 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 250 DepthToSpaceTest3<armnn::DataType::Float32>(
 251     armnn::IWorkloadFactory& workloadFactory,
 252     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 253     armnn::DataLayout dataLayout);
 254
 255 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
 256 DepthToSpaceTest4<armnn::DataType::Float32>(
 257     armnn::IWorkloadFactory& workloadFactory,
 258     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 259     armnn::DataLayout dataLayout);
 260
 261 // Float16
 262 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 263 DepthToSpaceTest1<armnn::DataType::Float16>(
 264     armnn::IWorkloadFactory& workloadFactory,
 265     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 266     armnn::DataLayout dataLayout);
 267
 268 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 269 DepthToSpaceTest2<armnn::DataType::Float16>(
 270     armnn::IWorkloadFactory& workloadFactory,
 271     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 272     armnn::DataLayout dataLayout);
 273
 274 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 275 DepthToSpaceTest3<armnn::DataType::Float16>(
 276     armnn::IWorkloadFactory& workloadFactory,
 277     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 278     armnn::DataLayout dataLayout);
 279
 280 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float16>, 4>
 281 DepthToSpaceTest4<armnn::DataType::Float16>(
 282     armnn::IWorkloadFactory& workloadFactory,
 283     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 284     armnn::DataLayout dataLayout);
 285
 286 // QuantisedAsymm8
 287 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
 288 DepthToSpaceTest1<armnn::DataType::QuantisedAsymm8>(
 289     armnn::IWorkloadFactory& workloadFactory,
 290     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 291     armnn::DataLayout dataLayout);
 292
 293 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
 294 DepthToSpaceTest2<armnn::DataType::QuantisedAsymm8>(
 295     armnn::IWorkloadFactory& workloadFactory,
 296     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 297     armnn::DataLayout dataLayout);
 298
 299 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
 300 DepthToSpaceTest3<armnn::DataType::QuantisedAsymm8>(
 301     armnn::IWorkloadFactory& workloadFactory,
 302     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 303     armnn::DataLayout dataLayout);
 304
 305 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
 306 DepthToSpaceTest4<armnn::DataType::QuantisedAsymm8>(
 307     armnn::IWorkloadFactory& workloadFactory,
 308     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 309     armnn::DataLayout dataLayout);
 310
 311 // QuantisedSymm16
 312 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
 313 DepthToSpaceTest1<armnn::DataType::QuantisedSymm16>(
 314     armnn::IWorkloadFactory& workloadFactory,
 315     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 316     armnn::DataLayout dataLayout);
 317
 318 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
 319 DepthToSpaceTest2<armnn::DataType::QuantisedSymm16>(
 320     armnn::IWorkloadFactory& workloadFactory,
 321     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 322     armnn::DataLayout dataLayout);
 323
 324 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
 325 DepthToSpaceTest3<armnn::DataType::QuantisedSymm16>(
 326     armnn::IWorkloadFactory& workloadFactory,
 327     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 328     armnn::DataLayout dataLayout);
 329
 330 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
 331 DepthToSpaceTest4<armnn::DataType::QuantisedSymm16>(
 332     armnn::IWorkloadFactory& workloadFactory,
 333     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 334     armnn::DataLayout dataLayout);