patch/20.08/_transpose_convolution2d_end_to_end_test_impl_8hpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #pragma once

 #include "QuantizeHelper.hpp"


 #include <armnnUtils/Permute.hpp>

 #include <QuantizeHelper.hpp>
 #include <ResolveType.hpp>

 #include <backendsCommon/test/CommonTestUtils.hpp>

 #include <boost/test/unit_test.hpp>

 #include <map>
 #include <vector>

 namespace
 {

 INetworkPtr CreateTransposeConvolution2dNetwork(const armnn::TransposeConvolution2dDescriptor& descriptor,
                                                 const armnn::TensorInfo& inputInfo,
                                                 const armnn::TensorInfo& outputInfo,
                                                 const armnn::ConstTensor& weights,
                                                 const armnn::Optional<armnn::ConstTensor>& biases)
 {
     using namespace armnn;

     INetworkPtr network(INetwork::Create());
     IConnectableLayer* input = network->AddInputLayer(0, "input");
     IConnectableLayer* transposeConvolution2d =
         network->AddTransposeConvolution2dLayer(descriptor, weights, biases, "transposeConvolution2d");
     IConnectableLayer* output = network->AddOutputLayer(0, "output");

     Connect(input, transposeConvolution2d, inputInfo, 0, 0);
     Connect(transposeConvolution2d, output, outputInfo, 0, 0);

     return network;
 }

 } // anonymous namespace

 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType>
 void TransposeConvolution2dEndToEnd(const std::vector<armnn::BackendId>& backends,
                                     armnn::DataLayout dataLayout)
 {
     using namespace armnn;
     using T = ResolveType<ArmnnType>;

     constexpr unsigned int batches  = 1u;
     constexpr unsigned int channels = 1u;

     constexpr unsigned int wInput = 3u;
     constexpr unsigned int hInput = wInput;

     constexpr unsigned int wOutput = 5u;
     constexpr unsigned int hOutput = wOutput;

     constexpr unsigned int wWeights = 3u;
     constexpr unsigned int hWeights = wWeights;

     TensorShape inputShape   = MakeTensorShape(batches, channels, hInput, wInput, dataLayout);
     TensorShape outputShape  = MakeTensorShape(batches, channels, hOutput, wOutput, dataLayout);
     TensorShape weightsShape = MakeTensorShape(batches, channels, hWeights, wWeights, dataLayout);

     const float   qScale  = IsQuantizedType<T>() ? 0.25f : 1.0f;
     const int32_t qOffset = IsQuantizedType<T>() ? 50    : 0;

     TensorInfo inputInfo(inputShape, ArmnnType, qScale, qOffset);
     TensorInfo outputInfo(outputShape, ArmnnType, qScale, qOffset);
     TensorInfo weightsInfo(weightsShape, ArmnnType, qScale, qOffset);
     TensorInfo biasesInfo({ channels }, ArmnnBType, qScale * qScale, 0);

     std::vector<float> inputData =
     {
        1.f, 1.f, 1.f,
        1.f, 1.f, 1.f,
        1.f, 1.f, 1.f
     };

     std::vector<float> weightsData =
     {
         1.f, 2.f, 3.f,
         4.f, 5.f, 6.f,
         7.f, 8.f, 9.f
     };

     std::vector<float> biasesData = { 1.f };

     std::vector<float> expectedOutputData =
     {
          6.f, 11.f,  6.f, 11.f,  6.f,
         11.f, 21.f, 11.f, 21.f, 11.f,
          6.f, 11.f,  6.f, 11.f,  6.f,
         11.f, 21.f, 11.f, 21.f, 11.f,
          6.f, 11.f,  6.f, 11.f,  6.f
     };

     TransposeConvolution2dDescriptor descriptor;
     descriptor.m_PadLeft     = 1;
     descriptor.m_PadRight    = 1;
     descriptor.m_PadTop      = 1;
     descriptor.m_PadBottom   = 1;
     descriptor.m_StrideX     = 2;
     descriptor.m_StrideY     = 2;
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = dataLayout;

     // swizzle data if needed
     if (dataLayout == armnn::DataLayout::NHWC)
     {
         constexpr size_t dataTypeSize = sizeof(float);
         const armnn::PermutationVector nchwToNhwc = { 0, 3, 1, 2 };

         std::vector<float> tmp(inputData.size());
         armnnUtils::Permute(inputInfo.GetShape(), nchwToNhwc, inputData.data(), tmp.data(), dataTypeSize);
         inputData = tmp;

         tmp.resize(weightsData.size());
         armnnUtils::Permute(weightsInfo.GetShape(), nchwToNhwc, weightsData.data(), tmp.data(), dataTypeSize);
         weightsData = tmp;

         tmp.resize(expectedOutputData.size());
         armnnUtils::Permute(outputInfo.GetShape(), nchwToNhwc, expectedOutputData.data(), tmp.data(), dataTypeSize);
         expectedOutputData = tmp;
     }

     // quantize data
     std::vector<T> qInputData          = armnnUtils::QuantizedVector<T>(inputData, qScale, qOffset);
     std::vector<T> qWeightsData        = armnnUtils::QuantizedVector<T>(weightsData, qScale, qOffset);
     std::vector<T> qExpectedOutputData = armnnUtils::QuantizedVector<T>(expectedOutputData, qScale, qOffset);

     using BT = ResolveType<ArmnnBType>;
     std::vector<BT> qBiasesData = armnnUtils::QuantizedVector<BT>(biasesData, qScale * qScale, 0);

     ConstTensor weights(weightsInfo, qWeightsData);
     ConstTensor biases(biasesInfo, qBiasesData);

     INetworkPtr network = CreateTransposeConvolution2dNetwork(descriptor,
                                                               inputInfo,
                                                               outputInfo,
                                                               weights,
                                                               Optional<ConstTensor>(biases));


     EndToEndLayerTestImpl<ArmnnType, ArmnnType>(std::move(network),
                                                 { { 0, qInputData } },
                                                 { { 0, qExpectedOutputData } },
                                                 backends);
 }
armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:61

+armnn::DataLayout
DataLayout
Definition: Types.hpp:49

+armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1196

+armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:187

+armnn::Optional< armnn::ConstTensor >

+armnn::TensorInfo
Definition: Tensor.hpp:152

+QuantizeHelper.hpp

+armnn::TransposeConvolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:1237

+armnn::ResolveType
typename ResolveTypeImpl< DT >::Type ResolveType
Definition: ResolveType.hpp:73

+ResolveType.hpp

+armnn
Copyright (c) 2020 ARM Limited.
Definition: 00_introduction.dox:25

+armnn::TransposeConvolution2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:1231

+armnn::TensorShape
Definition: Tensor.hpp:20

+TransposeConvolution2dEndToEnd
void TransposeConvolution2dEndToEnd(const std::vector< armnn::BackendId > &backends, armnn::DataLayout dataLayout)
Definition: TransposeConvolution2dEndToEndTestImpl.hpp:48

+CommonTestUtils.hpp

+Permute.hpp

+armnn::LayerType::Permute

+armnn::ConstTensor
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
Definition: Tensor.hpp:298

+armnn::TransposeConvolution2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:1229

+armnn::TransposeConvolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:1239

+armnn::PermutationVector
Definition: Types.hpp:196

+armnn::TransposeConvolution2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:1225

+armnn::TransposeConvolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:1233

+armnn::TransposeConvolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:1235

+armnn::TransposeConvolution2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:1227

+Connect
void Connect(armnn::IConnectableLayer *from, armnn::IConnectableLayer *to, const armnn::TensorInfo &tensorInfo, unsigned int fromIndex, unsigned int toIndex)
Definition: TestUtils.cpp:12

+MakeTensorShape
armnn::TensorShape MakeTensorShape(unsigned int batches, unsigned int channels, unsigned int height, unsigned int width, armnn::DataLayout layout)
Definition: CommonTestUtils.cpp:54

+armnn::INetworkPtr
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
Definition: INetwork.hpp:101

+armnn::INetwork::Create
static INetworkPtr Create(NetworkOptions networkOptions={})
Definition: Network.cpp:50

+armnn::DataLayout::NHWC

+