src/backends/backendsCommon/test/SpaceToBatchNdTestImpl.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5 #pragma once
   6
   7 #include "WorkloadTestUtils.hpp"
   8
   9 #include <armnn/ArmNN.hpp>
  10 #include <armnn/Tensor.hpp>
  11 #include <armnn/TypesUtils.hpp>
  12
  13 #include <backendsCommon/CpuTensorHandle.hpp>
  14 #include <backendsCommon/IBackendInternal.hpp>
  15 #include <backendsCommon/WorkloadFactory.hpp>
  16
  17 #include <test/TensorHelpers.hpp>
  18
  19 template<typename T>
  20 LayerTestResult<T, 4> SpaceToBatchNdTestImpl(
  21     armnn::IWorkloadFactory& workloadFactory,
  22     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  23     armnn::TensorInfo& inputTensorInfo,
  24     armnn::TensorInfo& outputTensorInfo,
  25     std::vector<float>& inputData,
  26     std::vector<float>& outputExpectedData,
  27     armnn::SpaceToBatchNdQueueDescriptor descriptor,
  28     const float qScale = 1.0f,
  29     const int32_t qOffset = 0)
  30 {
  31     const armnn::PermutationVector NCHWToNHWC = {0, 3, 1, 2};
  32     if (descriptor.m_Parameters.m_DataLayout == armnn::DataLayout::NHWC)
  33     {
  34         inputTensorInfo = armnnUtils::Permuted(inputTensorInfo, NCHWToNHWC);
  35         outputTensorInfo = armnnUtils::Permuted(outputTensorInfo, NCHWToNHWC);
  36
  37         std::vector<float> inputTmp(inputData.size());
  38         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC,
  39                             inputData.data(), inputTmp.data(), sizeof(float));
  40         inputData = inputTmp;
  41
  42         std::vector<float> outputTmp(outputExpectedData.size());
  43         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC,
  44                             outputExpectedData.data(), outputTmp.data(), sizeof(float));
  45         outputExpectedData = outputTmp;
  46     }
  47
  48     if(armnn::IsQuantizedType<T>())
  49     {
  50         inputTensorInfo.SetQuantizationScale(qScale);
  51         inputTensorInfo.SetQuantizationOffset(qOffset);
  52         outputTensorInfo.SetQuantizationScale(qScale);
  53         outputTensorInfo.SetQuantizationOffset(qOffset);
  54     }
  55
  56     boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, inputData));
  57
  58     LayerTestResult<T, 4> ret(outputTensorInfo);
  59     ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, outputExpectedData));
  60
  61     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
  62     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
  63
  64     armnn::WorkloadInfo info;
  65     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
  66     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
  67
  68     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateSpaceToBatchNd(descriptor, info);
  69
  70     inputHandle->Allocate();
  71     outputHandle->Allocate();
  72
  73     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
  74
  75     workload->Execute();
  76
  77     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
  78
  79     return ret;
  80 }
  81
  82 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
  83 LayerTestResult<T, 4> SpaceToBatchNdSimpleTest(
  84     armnn::IWorkloadFactory& workloadFactory,
  85     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  86     armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
  87 {
  88     armnn::TensorInfo inputTensorInfo;
  89     armnn::TensorInfo outputTensorInfo;
  90
  91     unsigned int inputShape[] = {1, 1, 2, 2};
  92     unsigned int outputShape[] = {4, 1, 1, 1};
  93
  94     armnn::SpaceToBatchNdQueueDescriptor desc;
  95     desc.m_Parameters.m_DataLayout = dataLayout;
  96     desc.m_Parameters.m_BlockShape = {2, 2};
  97     desc.m_Parameters.m_PadList = {{0, 0}, {0, 0}};
  98
  99     inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
 100     outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
 101
 102     std::vector<float> input = std::vector<float>(
 103     {
 104         1.0f, 2.0f, 3.0f, 4.0f
 105     });
 106
 107     std::vector<float> outputExpected = std::vector<float>(
 108     {
 109         1.0f, 2.0f, 3.0f, 4.0f
 110     });
 111
 112     return SpaceToBatchNdTestImpl<T>(
 113         workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 114 }
 115
 116 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 117 LayerTestResult<T, 4> SpaceToBatchNdMultiChannelsTest(
 118     armnn::IWorkloadFactory& workloadFactory,
 119     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 120     armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 121 {
 122     armnn::TensorInfo inputTensorInfo;
 123     armnn::TensorInfo outputTensorInfo;
 124
 125     unsigned int inputShape[] = {1, 3, 2, 2};
 126     unsigned int outputShape[] = {4, 3, 1, 1};
 127
 128     armnn::SpaceToBatchNdQueueDescriptor desc;
 129     desc.m_Parameters.m_DataLayout = dataLayout;
 130     desc.m_Parameters.m_BlockShape = {2, 2};
 131     desc.m_Parameters.m_PadList = {{0, 0}, {0, 0}};
 132
 133     inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
 134     outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
 135
 136     std::vector<float> input = std::vector<float>(
 137     {
 138         1.0f, 4.0f, 7.0f, 10.0f,
 139         2.0f, 5.0, 8.0, 11.0f,
 140         3.0f, 6.0f, 9.0f, 12.0f
 141     });
 142
 143     std::vector<float> outputExpected = std::vector<float>(
 144     {
 145         1.0f, 2.0f, 3.0f,
 146         4.0f, 5.0f, 6.0f,
 147         7.0f, 8.0f, 9.0f,
 148         10.0f, 11.0f, 12.0f
 149     });
 150
 151     return SpaceToBatchNdTestImpl<T>(
 152         workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 153 }
 154
 155 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 156 LayerTestResult<T, 4> SpaceToBatchNdMultiBlockTest(
 157     armnn::IWorkloadFactory& workloadFactory,
 158     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 159     armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 160 {
 161     armnn::TensorInfo inputTensorInfo;
 162     armnn::TensorInfo outputTensorInfo;
 163
 164     unsigned int inputShape[] = {1, 1, 4, 4};
 165     unsigned int outputShape[] = {4, 1, 2, 2};
 166
 167     armnn::SpaceToBatchNdQueueDescriptor desc;
 168     desc.m_Parameters.m_DataLayout = dataLayout;
 169     desc.m_Parameters.m_BlockShape = {2, 2};
 170     desc.m_Parameters.m_PadList = {{0, 0}, {0, 0}};
 171
 172     inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
 173     outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
 174
 175     std::vector<float> input = std::vector<float>(
 176     {
 177         1.0f, 2.0f, 3.0f, 4.0f,
 178         5.0f, 6.0f, 7.0f, 8.0f,
 179         9.0f, 10.0f, 11.0f, 12.0f,
 180         13.0f, 14.0f, 15.0f, 16.0f
 181     });
 182
 183     std::vector<float> outputExpected = std::vector<float>(
 184     {
 185         1.0f, 3.0f, 9.0f, 11.0f,
 186         2.0f, 4.0f, 10.0f, 12.0f,
 187         5.0f, 7.0f, 13.0f, 15.0f,
 188         6.0f, 8.0f, 14.0f, 16.0f
 189     });
 190
 191     return SpaceToBatchNdTestImpl<T>(
 192         workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 193 }
 194
 195 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 196 LayerTestResult<T, 4> SpaceToBatchNdPaddingTest(
 197     armnn::IWorkloadFactory& workloadFactory,
 198     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 199     armnn::DataLayout dataLayout = armnn::DataLayout::NCHW)
 200 {
 201     armnn::TensorInfo inputTensorInfo;
 202     armnn::TensorInfo outputTensorInfo;
 203
 204     unsigned int inputShape[] = {2, 1, 2, 4};
 205     unsigned int outputShape[] = {8, 1, 1, 3};
 206
 207     armnn::SpaceToBatchNdQueueDescriptor desc;
 208     desc.m_Parameters.m_DataLayout = dataLayout;
 209     desc.m_Parameters.m_BlockShape = {2, 2};
 210     desc.m_Parameters.m_PadList = {{0, 0}, {2, 0}};
 211
 212     inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
 213     outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
 214
 215     std::vector<float> input = std::vector<float>(
 216     {
 217         1.0f, 2.0f, 3.0f, 4.0f,
 218         5.0f, 6.0f, 7.0f, 8.0f,
 219         9.0f, 10.0f, 11.0f, 12.0f,
 220         13.0f, 14.0f, 15.0f, 16.0f
 221     });
 222
 223     std::vector<float> outputExpected = std::vector<float>(
 224     {
 225         0.0f, 1.0f, 3.0f,
 226         0.0f, 9.0f, 11.0f,
 227         0.0f, 2.0f, 4.0f,
 228         0.0f, 10.0f, 12.0f,
 229         0.0f, 5.0f, 7.0f,
 230         0.0f, 13.0f, 15.0f,
 231         0.0f, 6.0f, 8.0f,
 232         0.0f, 14.0f, 16.0f
 233     });
 234
 235     return SpaceToBatchNdTestImpl<T>(
 236         workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected, desc);
 237 }
 238
 239 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 240 LayerTestResult<T, 4> SpaceToBatchNdSimpleNHWCTest(
 241     armnn::IWorkloadFactory& workloadFactory,
 242     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 243 {
 244     return SpaceToBatchNdSimpleTest<ArmnnType>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 245 }
 246
 247 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 248 LayerTestResult<T, 4> SpaceToBatchNdMultiChannelsNHWCTest(
 249     armnn::IWorkloadFactory& workloadFactory,
 250     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 251 {
 252     return SpaceToBatchNdMultiChannelsTest<ArmnnType>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 253 }
 254
 255 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 256 LayerTestResult<T, 4> SpaceToBatchNdMultiBlockNHWCTest(
 257     armnn::IWorkloadFactory& workloadFactory,
 258     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 259 {
 260     return SpaceToBatchNdMultiBlockTest<ArmnnType>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 261 }
 262
 263 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 264 LayerTestResult<T, 4> SpaceToBatchNdPaddingNHWCTest(
 265     armnn::IWorkloadFactory& workloadFactory,
 266     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
 267 {
 268     return SpaceToBatchNdPaddingTest<ArmnnType>(workloadFactory, memoryManager, armnn::DataLayout::NHWC);
 269 }