src/backends/backendsCommon/test/ReshapeTestImpl.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5 #pragma once
   6
   7 #include "QuantizeHelper.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/WorkloadFactory.hpp>
  15
  16 #include <test/TensorHelpers.hpp>
  17
  18 template<typename T>
  19 LayerTestResult<T, 4> SimpleReshapeTestImpl(
  20     armnn::IWorkloadFactory& workloadFactory,
  21     armnn::TensorInfo inputTensorInfo,
  22     armnn::TensorInfo outputTensorInfo,
  23     const std::vector<T>& inputData,
  24     const std::vector<T>& outputExpectedData)
  25 {
  26     auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
  27
  28     LayerTestResult<T, 4> ret(outputTensorInfo);
  29     ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputExpectedData);
  30
  31     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
  32     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
  33
  34     armnn::ReshapeQueueDescriptor data;
  35     armnn::WorkloadInfo info;
  36     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
  37     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
  38
  39     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateReshape(data, info);
  40
  41     inputHandle->Allocate();
  42     outputHandle->Allocate();
  43
  44     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
  45
  46     workload->Execute();
  47
  48     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
  49
  50     return ret;
  51 }
  52
  53 LayerTestResult<float, 4> SimpleReshapeFloat32Test(armnn::IWorkloadFactory& workloadFactory)
  54 {
  55     armnn::TensorInfo inputTensorInfo;
  56     armnn::TensorInfo outputTensorInfo;
  57
  58     unsigned int inputShape[] = { 2, 2, 3, 3 };
  59     unsigned int outputShape[] = { 2, 2, 9, 1 };
  60
  61     inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32);
  62     outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32);
  63
  64     std::vector<float> input = std::vector<float>(
  65     {
  66         0.0f, 1.0f, 2.0f,
  67         3.0f, 4.0f, 5.0f,
  68         6.0f, 7.0f, 8.0f,
  69
  70         9.0f, 10.0f, 11.0f,
  71         12.0f, 13.0f, 14.0f,
  72         15.0f, 16.0f, 17.0f,
  73
  74         18.0f, 19.0f, 20.0f,
  75         21.0f, 22.0f, 23.0f,
  76         24.0f, 25.0f, 26.0f,
  77
  78         27.0f, 28.0f, 29.0f,
  79         30.0f, 31.0f, 32.0f,
  80         33.0f, 34.0f, 35.0f,
  81     });
  82
  83     std::vector<float> outputExpected = std::vector<float>(
  84     {
  85         0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
  86
  87         9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
  88
  89         18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f,
  90
  91         27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f, 33.0f, 34.0f, 35.0f,
  92     });
  93
  94     return SimpleReshapeTestImpl<float>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected);
  95 }
  96
  97 LayerTestResult<float, 4> SimpleFloorTest(armnn::IWorkloadFactory& workloadFactory)
  98 {
  99     const armnn::TensorInfo inputTensorInfo({1, 3, 2, 3}, armnn::DataType::Float32);
 100     const armnn::TensorInfo outputTensorInfo(inputTensorInfo);
 101
 102     auto input = MakeTensor<float, 4>(inputTensorInfo,
 103         { -37.5f, -15.2f, -8.76f, -2.0f, -1.5f, -1.3f, -0.5f, -0.4f, 0.0f,
 104           1.0f, 0.4f, 0.5f, 1.3f, 1.5f, 2.0f, 8.76f, 15.2f, 37.5f });
 105
 106     LayerTestResult<float, 4> ret(outputTensorInfo);
 107     ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo,
 108         { -38.0f, -16.0f, -9.0f, -2.0f, -2.0f, -2.0f, -1.0f, -1.0f, 0.0f,
 109           1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 8.0f, 15.0f, 37.0f });
 110
 111     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
 112     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
 113
 114     armnn::FloorQueueDescriptor data;
 115     armnn::WorkloadInfo info;
 116     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
 117     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
 118
 119     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateFloor(data, info);
 120
 121     inputHandle->Allocate();
 122     outputHandle->Allocate();
 123
 124     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
 125
 126     workload->Execute();
 127
 128     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
 129
 130     return ret;
 131 }
 132
 133 LayerTestResult<uint8_t, 4> SimpleReshapeUint8Test(armnn::IWorkloadFactory& workloadFactory)
 134 {
 135     armnn::TensorInfo inputTensorInfo;
 136     armnn::TensorInfo outputTensorInfo;
 137
 138     unsigned int inputShape[] = { 2, 2, 3, 3 };
 139     unsigned int outputShape[] = { 2, 2, 9, 1 };
 140
 141     inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::QuantisedAsymm8);
 142     inputTensorInfo.SetQuantizationScale(1.0f);
 143     outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::QuantisedAsymm8);
 144     outputTensorInfo.SetQuantizationScale(1.0f);
 145
 146     std::vector<uint8_t> input = std::vector<uint8_t>(
 147     {
 148         0, 1, 2,
 149         3, 4, 5,
 150         6, 7, 8,
 151
 152         9, 10, 11,
 153         12, 13, 14,
 154         15, 16, 17,
 155
 156         18, 19, 20,
 157         21, 22, 23,
 158         24, 25, 26,
 159
 160         27, 28, 29,
 161         30, 31, 32,
 162         33, 34, 35,
 163     });
 164
 165     std::vector<uint8_t> outputExpected = std::vector<uint8_t>(
 166     {
 167         0, 1, 2, 3, 4, 5, 6, 7, 8,
 168
 169         9, 10, 11, 12, 13, 14, 15, 16, 17,
 170
 171         18, 19, 20, 21, 22, 23, 24, 25, 26,
 172
 173         27, 28, 29, 30, 31, 32, 33, 34, 35,
 174     });
 175
 176     return SimpleReshapeTestImpl<uint8_t>(workloadFactory, inputTensorInfo, outputTensorInfo, input, outputExpected);
 177 }