#include "../Serializer.hpp"
#include "SerializerTestUtils.hpp"
#include <armnn/Descriptors.hpp>
#include <armnn/INetwork.hpp>
#include <armnn/TypesUtils.hpp>
#include <armnn/LstmParams.hpp>
#include <armnn/QuantizedLstmParams.hpp>
#include <armnnDeserializer/IDeserializer.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
#include <random>
#include <vector>
#include <boost/test/unit_test.hpp>

Functions
	BOOST_AUTO_TEST_CASE (SerializeAbs)

	BOOST_AUTO_TEST_CASE (SerializeAddition)

	BOOST_AUTO_TEST_CASE (SerializeArgMinMax)

	BOOST_AUTO_TEST_CASE (SerializeBatchNormalization)

	BOOST_AUTO_TEST_CASE (SerializeBatchToSpaceNd)

	BOOST_AUTO_TEST_CASE (SerializeComparison)

	BOOST_AUTO_TEST_CASE (SerializeConstant)

	BOOST_AUTO_TEST_CASE (SerializeConvolution2d)

	BOOST_AUTO_TEST_CASE (SerializeConvolution2dWithPerAxisParams)

	BOOST_AUTO_TEST_CASE (SerializeDepthToSpace)

	BOOST_AUTO_TEST_CASE (SerializeDepthwiseConvolution2d)

	BOOST_AUTO_TEST_CASE (SerializeDepthwiseConvolution2dWithPerAxisParams)

	BOOST_AUTO_TEST_CASE (SerializeDequantize)

	BOOST_AUTO_TEST_CASE (SerializeDeserializeDetectionPostProcess)

	BOOST_AUTO_TEST_CASE (SerializeDivision)

	BOOST_AUTO_TEST_CASE (SerializeDeserializeEqual)

	BOOST_AUTO_TEST_CASE (SerializeFill)

	BOOST_AUTO_TEST_CASE (SerializeFloor)

	BOOST_AUTO_TEST_CASE (SerializeFullyConnected)

	BOOST_AUTO_TEST_CASE (SerializeGather)

	BOOST_AUTO_TEST_CASE (SerializeGreaterDeprecated)

	BOOST_AUTO_TEST_CASE (SerializeInstanceNormalization)

	BOOST_AUTO_TEST_CASE (SerializeL2Normalization)

	BOOST_AUTO_TEST_CASE (EnsureL2NormalizationBackwardCompatibility)

	BOOST_AUTO_TEST_CASE (SerializeLogicalBinary)

	BOOST_AUTO_TEST_CASE (SerializeLogicalUnary)

	BOOST_AUTO_TEST_CASE (SerializeLogSoftmax)

	BOOST_AUTO_TEST_CASE (SerializeMaximum)

	BOOST_AUTO_TEST_CASE (SerializeMean)

	BOOST_AUTO_TEST_CASE (SerializeMerge)

	BOOST_AUTO_TEST_CASE (SerializeMerger)

	BOOST_AUTO_TEST_CASE (EnsureMergerLayerBackwardCompatibility)

	BOOST_AUTO_TEST_CASE (SerializeConcat)

	BOOST_AUTO_TEST_CASE (SerializeMinimum)

	BOOST_AUTO_TEST_CASE (SerializeMultiplication)

	BOOST_AUTO_TEST_CASE (SerializePrelu)

	BOOST_AUTO_TEST_CASE (SerializeNormalization)

	BOOST_AUTO_TEST_CASE (SerializePad)

	BOOST_AUTO_TEST_CASE (EnsurePadBackwardCompatibility)

	BOOST_AUTO_TEST_CASE (SerializePermute)

	BOOST_AUTO_TEST_CASE (SerializePooling2d)

	BOOST_AUTO_TEST_CASE (SerializeQuantize)

	BOOST_AUTO_TEST_CASE (SerializeRank)

	BOOST_AUTO_TEST_CASE (SerializeReduceSum)

	BOOST_AUTO_TEST_CASE (SerializeReshape)

	BOOST_AUTO_TEST_CASE (SerializeResize)

	BOOST_AUTO_TEST_CASE (SerializeResizeBilinear)

	BOOST_AUTO_TEST_CASE (EnsureResizeBilinearBackwardCompatibility)

	BOOST_AUTO_TEST_CASE (SerializeSlice)

	BOOST_AUTO_TEST_CASE (SerializeSoftmax)

	BOOST_AUTO_TEST_CASE (SerializeSpaceToBatchNd)

	BOOST_AUTO_TEST_CASE (SerializeSpaceToDepth)

	BOOST_AUTO_TEST_CASE (SerializeSplitter)

	BOOST_AUTO_TEST_CASE (SerializeStack)

	BOOST_AUTO_TEST_CASE (SerializeStandIn)

	BOOST_AUTO_TEST_CASE (SerializeStridedSlice)

	BOOST_AUTO_TEST_CASE (SerializeSubtraction)

	BOOST_AUTO_TEST_CASE (SerializeSwitch)

	BOOST_AUTO_TEST_CASE (SerializeTranspose)

	BOOST_AUTO_TEST_CASE (SerializeTransposeConvolution2d)

	BOOST_AUTO_TEST_CASE (SerializeDeserializeNonLinearNetwork)

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/61]

BOOST_AUTO_TEST_CASE ( SerializeAbs )

Definition at line 26 of file SerializerTests.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("abs");
     const armnn::TensorInfo tensorInfo({1, 2, 3}, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
 
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     armnn::IConnectableLayer* const absLayer = network->AddAbsLayer(layerName.c_str());
     ARMNN_NO_DEPRECATE_WARN_END
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(absLayer->GetInputSlot(0));
     absLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     absLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {tensorInfo}, {tensorInfo});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [2/61]

BOOST_AUTO_TEST_CASE ( SerializeAddition )

Definition at line 52 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("addition");
     const armnn::TensorInfo tensorInfo({1, 2, 3}, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const additionLayer = network->AddAdditionLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(additionLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(additionLayer->GetInputSlot(1));
     additionLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     additionLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     std::string serializedNetwork = SerializeNetwork(*network);
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(serializedNetwork);
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {tensorInfo, tensorInfo}, {tensorInfo});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [3/61]

BOOST_AUTO_TEST_CASE ( SerializeArgMinMax )

Definition at line 79 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), ArgMinMaxDescriptor::m_Function, armnn::Max, SerializeNetwork(), IOutputSlot::SetTensorInfo(), and armnn::Signed32.

 {
     const std::string layerName("argminmax");
     const armnn::TensorInfo inputInfo({1, 2, 3}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({1, 3}, armnn::DataType::Signed32);
 
     armnn::ArgMinMaxDescriptor descriptor;
     descriptor.m_Function = armnn::ArgMinMaxFunction::Max;
     descriptor.m_Axis = 1;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const argMinMaxLayer = network->AddArgMinMaxLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(argMinMaxLayer->GetInputSlot(0));
     argMinMaxLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     argMinMaxLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ArgMinMaxDescriptor> verifier(layerName,
                                                                          {inputInfo},
                                                                          {outputInfo},
                                                                          descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [4/61]

BOOST_AUTO_TEST_CASE ( SerializeBatchNormalization )

Definition at line 110 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptorAndConstants< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), BatchNormalizationDescriptor::m_Eps, armnn::NHWC, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("batchNormalization");
     const armnn::TensorInfo inputInfo ({ 1, 3, 3, 1 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
 
     const armnn::TensorInfo meanInfo({1}, armnn::DataType::Float32);
     const armnn::TensorInfo varianceInfo({1}, armnn::DataType::Float32);
     const armnn::TensorInfo betaInfo({1}, armnn::DataType::Float32);
     const armnn::TensorInfo gammaInfo({1}, armnn::DataType::Float32);
 
     armnn::BatchNormalizationDescriptor descriptor;
     descriptor.m_Eps = 0.0010000000475f;
     descriptor.m_DataLayout = armnn::DataLayout::NHWC;
 
     std::vector<float> meanData({5.0});
     std::vector<float> varianceData({2.0});
     std::vector<float> betaData({1.0});
     std::vector<float> gammaData({0.0});
 
     std::vector<armnn::ConstTensor> constants;
     constants.emplace_back(armnn::ConstTensor(meanInfo, meanData));
     constants.emplace_back(armnn::ConstTensor(varianceInfo, varianceData));
     constants.emplace_back(armnn::ConstTensor(betaInfo, betaData));
     constants.emplace_back(armnn::ConstTensor(gammaInfo, gammaData));
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const batchNormalizationLayer =
         network->AddBatchNormalizationLayer(descriptor,
                                             constants[0],
                                             constants[1],
                                             constants[2],
                                             constants[3],
                                             layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(batchNormalizationLayer->GetInputSlot(0));
     batchNormalizationLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     batchNormalizationLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptorAndConstants<armnn::BatchNormalizationDescriptor> verifier(
         layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [5/61]

BOOST_AUTO_TEST_CASE ( SerializeBatchToSpaceNd )

Definition at line 161 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), BatchToSpaceNdDescriptor::m_DataLayout, armnn::NCHW, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("spaceToBatchNd");
     const armnn::TensorInfo inputInfo({4, 1, 2, 2}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({1, 1, 4, 4}, armnn::DataType::Float32);
 
     armnn::BatchToSpaceNdDescriptor desc;
     desc.m_DataLayout = armnn::DataLayout::NCHW;
     desc.m_BlockShape = {2, 2};
     desc.m_Crops = {{0, 0}, {0, 0}};
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const batchToSpaceNdLayer = network->AddBatchToSpaceNdLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(batchToSpaceNdLayer->GetInputSlot(0));
     batchToSpaceNdLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     batchToSpaceNdLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::BatchToSpaceNdDescriptor> verifier(layerName,
                                                                               {inputInfo},
                                                                               {outputInfo},
                                                                               desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [6/61]

BOOST_AUTO_TEST_CASE ( SerializeComparison )

Definition at line 193 of file SerializerTests.cpp.

References armnn::Boolean, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::NotEqual, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("comparison");
 
     const armnn::TensorShape shape{2, 1, 2, 4};
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
 
     armnn::ComparisonDescriptor descriptor(armnn::ComparisonOperation::NotEqual);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0     = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1     = network->AddInputLayer(1);
     armnn::IConnectableLayer* const comparisonLayer = network->AddComparisonLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer     = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(comparisonLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(comparisonLayer->GetInputSlot(1));
     comparisonLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(inputInfo);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(inputInfo);
     comparisonLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ComparisonDescriptor> verifier(layerName,
                                                                           { inputInfo, inputInfo },
                                                                           { outputInfo },
                                                                           descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [7/61]

BOOST_AUTO_TEST_CASE ( SerializeConstant )

Definition at line 228 of file SerializerTests.cpp.

References armnn::Addition, CompareConstTensor(), IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, LayerVerifierBase::LayerVerifierBase(), armnn::Output, SerializeNetwork(), IOutputSlot::SetTensorInfo(), and LayerVerifierBase::VerifyNameAndConnections().

 {
     class ConstantLayerVerifier : public LayerVerifierBase
     {
     public:
         ConstantLayerVerifier(const std::string& layerName,
                               const std::vector<armnn::TensorInfo>& inputInfos,
                               const std::vector<armnn::TensorInfo>& outputInfos,
                               const std::vector<armnn::ConstTensor>& constants)
             : LayerVerifierBase(layerName, inputInfos, outputInfos)
             , m_Constants(constants) {}
 
         void ExecuteStrategy(const armnn::IConnectableLayer* layer,
                              const armnn::BaseDescriptor& descriptor,
                              const std::vector<armnn::ConstTensor>& constants,
                              const char* name,
                              const armnn::LayerBindingId id = 0) override
         {
             armnn::IgnoreUnused(descriptor, id);
 
             switch (layer->GetType())
             {
                 case armnn::LayerType::Input: break;
                 case armnn::LayerType::Output: break;
                 case armnn::LayerType::Addition: break;
                 default:
                 {
                     this->VerifyNameAndConnections(layer, name);
 
                     for (std::size_t i = 0; i < constants.size(); i++)
                     {
                         CompareConstTensor(constants[i], m_Constants[i]);
                     }
                 }
             }
         }
 
     private:
         const std::vector<armnn::ConstTensor> m_Constants;
     };
 
     const std::string layerName("constant");
     const armnn::TensorInfo info({ 2, 3 }, armnn::DataType::Float32);
 
     std::vector<float> constantData = GenerateRandomData<float>(info.GetNumElements());
     armnn::ConstTensor constTensor(info, constantData);
 
     armnn::INetworkPtr network(armnn::INetwork::Create());
     armnn::IConnectableLayer* input = network->AddInputLayer(0);
     armnn::IConnectableLayer* constant = network->AddConstantLayer(constTensor, layerName.c_str());
     armnn::IConnectableLayer* add = network->AddAdditionLayer();
     armnn::IConnectableLayer* output = network->AddOutputLayer(0);
 
     input->GetOutputSlot(0).Connect(add->GetInputSlot(0));
     constant->GetOutputSlot(0).Connect(add->GetInputSlot(1));
     add->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     input->GetOutputSlot(0).SetTensorInfo(info);
     constant->GetOutputSlot(0).SetTensorInfo(info);
     add->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     ConstantLayerVerifier verifier(layerName, {}, {info}, {constTensor});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [8/61]

BOOST_AUTO_TEST_CASE ( SerializeConvolution2d )

Definition at line 296 of file SerializerTests.cpp.

 {
     const std::string layerName("convolution2d");
     const armnn::TensorInfo inputInfo ({ 1, 5, 5, 1 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
 
     const armnn::TensorInfo weightsInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
     const armnn::TensorInfo biasesInfo ({ 1 }, armnn::DataType::Float32);
 
     std::vector<float> weightsData = GenerateRandomData<float>(weightsInfo.GetNumElements());
     armnn::ConstTensor weights(weightsInfo, weightsData);
 
     std::vector<float> biasesData = GenerateRandomData<float>(biasesInfo.GetNumElements());
     armnn::ConstTensor biases(biasesInfo, biasesData);
 
     armnn::Convolution2dDescriptor 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_DilationX   = 2;
     descriptor.m_DilationY   = 2;
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer  = network->AddInputLayer(0);
     armnn::IConnectableLayer* const convLayer   =
             network->AddConvolution2dLayer(descriptor,
                                            weights,
                                            armnn::Optional<armnn::ConstTensor>(biases),
                                            layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(convLayer->GetInputSlot(0));
     convLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     convLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor>& constants {weights, biases};
     LayerVerifierBaseWithDescriptorAndConstants<armnn::Convolution2dDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [9/61]

BOOST_AUTO_TEST_CASE ( SerializeConvolution2dWithPerAxisParams )

Definition at line 347 of file SerializerTests.cpp.

 {
     using namespace armnn;
 
     const std::string layerName("convolution2dWithPerAxis");
     const TensorInfo inputInfo ({ 1, 3, 1, 2 }, DataType::QAsymmU8, 0.55f, 128);
     const TensorInfo outputInfo({ 1, 3, 1, 3 }, DataType::QAsymmU8, 0.75f, 128);
 
     const std::vector<float> quantScales{ 0.75f, 0.65f, 0.85f };
     constexpr unsigned int quantDimension = 0;
 
     const TensorInfo kernelInfo({ 3, 1, 1, 2 }, DataType::QSymmS8, quantScales, quantDimension);
 
     const std::vector<float> biasQuantScales{ 0.25f, 0.50f, 0.75f };
     const TensorInfo biasInfo({ 3 }, DataType::Signed32, biasQuantScales, quantDimension);
 
     std::vector<int8_t> kernelData = GenerateRandomData<int8_t>(kernelInfo.GetNumElements());
     armnn::ConstTensor weights(kernelInfo, kernelData);
     std::vector<int32_t> biasData = GenerateRandomData<int32_t>(biasInfo.GetNumElements());
     armnn::ConstTensor biases(biasInfo, biasData);
 
     Convolution2dDescriptor descriptor;
     descriptor.m_StrideX     = 1;
     descriptor.m_StrideY     = 1;
     descriptor.m_PadLeft     = 0;
     descriptor.m_PadRight    = 0;
     descriptor.m_PadTop      = 0;
     descriptor.m_PadBottom   = 0;
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer  = network->AddInputLayer(0);
     armnn::IConnectableLayer* const convLayer   =
         network->AddConvolution2dLayer(descriptor,
                                        weights,
                                        armnn::Optional<armnn::ConstTensor>(biases),
                                        layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(convLayer->GetInputSlot(0));
     convLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     convLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor>& constants {weights, biases};
     LayerVerifierBaseWithDescriptorAndConstants<Convolution2dDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [10/61]

BOOST_AUTO_TEST_CASE ( SerializeDepthToSpace )

Definition at line 402 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SpaceToDepthDescriptor::m_BlockSize, armnn::NHWC, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("depthToSpace");
 
     const armnn::TensorInfo inputInfo ({ 1,  8, 4, 12 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 1, 16, 8,  3 }, armnn::DataType::Float32);
 
     armnn::DepthToSpaceDescriptor desc;
     desc.m_BlockSize  = 2;
     desc.m_DataLayout = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer        = network->AddInputLayer(0);
     armnn::IConnectableLayer* const depthToSpaceLayer = network->AddDepthToSpaceLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer       = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(depthToSpaceLayer->GetInputSlot(0));
     depthToSpaceLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     depthToSpaceLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::DepthToSpaceDescriptor> verifier(layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [11/61]

BOOST_AUTO_TEST_CASE ( SerializeDepthwiseConvolution2d )

Definition at line 431 of file SerializerTests.cpp.

 {
     const std::string layerName("depwiseConvolution2d");
     const armnn::TensorInfo inputInfo ({ 1, 5, 5, 3 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 1, 3, 3, 3 }, armnn::DataType::Float32);
 
     const armnn::TensorInfo weightsInfo({ 1, 3, 3, 3 }, armnn::DataType::Float32);
     const armnn::TensorInfo biasesInfo ({ 3 }, armnn::DataType::Float32);
 
     std::vector<float> weightsData = GenerateRandomData<float>(weightsInfo.GetNumElements());
     armnn::ConstTensor weights(weightsInfo, weightsData);
 
     std::vector<int32_t> biasesData = GenerateRandomData<int32_t>(biasesInfo.GetNumElements());
     armnn::ConstTensor biases(biasesInfo, biasesData);
 
     armnn::DepthwiseConvolution2dDescriptor 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_DilationX   = 2;
     descriptor.m_DilationY   = 2;
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const depthwiseConvLayer =
         network->AddDepthwiseConvolution2dLayer(descriptor,
                                                 weights,
                                                 armnn::Optional<armnn::ConstTensor>(biases),
                                                 layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(depthwiseConvLayer->GetInputSlot(0));
     depthwiseConvLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     depthwiseConvLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor>& constants {weights, biases};
     LayerVerifierBaseWithDescriptorAndConstants<armnn::DepthwiseConvolution2dDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [12/61]

BOOST_AUTO_TEST_CASE ( SerializeDepthwiseConvolution2dWithPerAxisParams )

Definition at line 482 of file SerializerTests.cpp.

 {
     using namespace armnn;
 
     const std::string layerName("depwiseConvolution2dWithPerAxis");
     const TensorInfo inputInfo ({ 1, 3, 3, 2 }, DataType::QAsymmU8, 0.55f, 128);
     const TensorInfo outputInfo({ 1, 2, 2, 4 }, DataType::QAsymmU8, 0.75f, 128);
 
     const std::vector<float> quantScales{ 0.75f, 0.80f, 0.90f, 0.95f };
     const unsigned int quantDimension = 0;
     TensorInfo kernelInfo({ 2, 2, 2, 2 }, DataType::QSymmS8, quantScales, quantDimension);
 
     const std::vector<float> biasQuantScales{ 0.25f, 0.35f, 0.45f, 0.55f };
     constexpr unsigned int biasQuantDimension = 0;
     TensorInfo biasInfo({ 4 }, DataType::Signed32, biasQuantScales, biasQuantDimension);
 
     std::vector<int8_t> kernelData = GenerateRandomData<int8_t>(kernelInfo.GetNumElements());
     armnn::ConstTensor weights(kernelInfo, kernelData);
     std::vector<int32_t> biasData = GenerateRandomData<int32_t>(biasInfo.GetNumElements());
     armnn::ConstTensor biases(biasInfo, biasData);
 
     DepthwiseConvolution2dDescriptor descriptor;
     descriptor.m_StrideX     = 1;
     descriptor.m_StrideY     = 1;
     descriptor.m_PadLeft     = 0;
     descriptor.m_PadRight    = 0;
     descriptor.m_PadTop      = 0;
     descriptor.m_PadBottom   = 0;
     descriptor.m_DilationX   = 1;
     descriptor.m_DilationY   = 1;
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const depthwiseConvLayer =
         network->AddDepthwiseConvolution2dLayer(descriptor,
                                                 weights,
                                                 armnn::Optional<armnn::ConstTensor>(biases),
                                                 layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(depthwiseConvLayer->GetInputSlot(0));
     depthwiseConvLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     depthwiseConvLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor>& constants {weights, biases};
     LayerVerifierBaseWithDescriptorAndConstants<armnn::DepthwiseConvolution2dDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [13/61]

BOOST_AUTO_TEST_CASE ( SerializeDequantize )

Definition at line 539 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::QAsymmU8, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("dequantize");
     const armnn::TensorInfo inputInfo({ 1, 5, 2, 3 }, armnn::DataType::QAsymmU8, 0.5f, 1);
     const armnn::TensorInfo outputInfo({ 1, 5, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const dequantizeLayer = network->AddDequantizeLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(dequantizeLayer->GetInputSlot(0));
     dequantizeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     dequantizeLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [14/61]

BOOST_AUTO_TEST_CASE ( SerializeDeserializeDetectionPostProcess )

Definition at line 563 of file SerializerTests.cpp.

 {
     const std::string layerName("detectionPostProcess");
 
     const std::vector<armnn::TensorInfo> inputInfos({
         armnn::TensorInfo({ 1, 6, 4 }, armnn::DataType::Float32),
         armnn::TensorInfo({ 1, 6, 3}, armnn::DataType::Float32)
     });
 
     const std::vector<armnn::TensorInfo> outputInfos({
         armnn::TensorInfo({ 1, 3, 4 }, armnn::DataType::Float32),
         armnn::TensorInfo({ 1, 3 }, armnn::DataType::Float32),
         armnn::TensorInfo({ 1, 3 }, armnn::DataType::Float32),
         armnn::TensorInfo({ 1 }, armnn::DataType::Float32)
     });
 
     armnn::DetectionPostProcessDescriptor descriptor;
     descriptor.m_UseRegularNms = true;
     descriptor.m_MaxDetections = 3;
     descriptor.m_MaxClassesPerDetection = 1;
     descriptor.m_DetectionsPerClass =1;
     descriptor.m_NmsScoreThreshold = 0.0;
     descriptor.m_NmsIouThreshold = 0.5;
     descriptor.m_NumClasses = 2;
     descriptor.m_ScaleY = 10.0;
     descriptor.m_ScaleX = 10.0;
     descriptor.m_ScaleH = 5.0;
     descriptor.m_ScaleW = 5.0;
 
     const armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32);
     const std::vector<float> anchorsData({
         0.5f, 0.5f, 1.0f, 1.0f,
         0.5f, 0.5f, 1.0f, 1.0f,
         0.5f, 0.5f, 1.0f, 1.0f,
         0.5f, 10.5f, 1.0f, 1.0f,
         0.5f, 10.5f, 1.0f, 1.0f,
         0.5f, 100.5f, 1.0f, 1.0f
     });
     armnn::ConstTensor anchors(anchorsInfo, anchorsData);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const detectionLayer =
         network->AddDetectionPostProcessLayer(descriptor, anchors, layerName.c_str());
 
     for (unsigned int i = 0; i < 2; i++)
     {
         armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(static_cast<int>(i));
         inputLayer->GetOutputSlot(0).Connect(detectionLayer->GetInputSlot(i));
         inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfos[i]);
     }
 
     for (unsigned int i = 0; i < 4; i++)
     {
         armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(static_cast<int>(i));
         detectionLayer->GetOutputSlot(i).Connect(outputLayer->GetInputSlot(0));
         detectionLayer->GetOutputSlot(i).SetTensorInfo(outputInfos[i]);
     }
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor>& constants {anchors};
     LayerVerifierBaseWithDescriptorAndConstants<armnn::DetectionPostProcessDescriptor> verifier(
             layerName, inputInfos, outputInfos, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [15/61]

BOOST_AUTO_TEST_CASE ( SerializeDivision )

Definition at line 630 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("division");
     const armnn::TensorInfo info({ 1, 5, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const divisionLayer = network->AddDivisionLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(divisionLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(divisionLayer->GetInputSlot(1));
     divisionLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
     divisionLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info, info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [16/61]

BOOST_AUTO_TEST_CASE ( SerializeDeserializeEqual )

Definition at line 656 of file SerializerTests.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::Boolean, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("EqualLayer");
     const armnn::TensorInfo inputTensorInfo1 = armnn::TensorInfo({2, 1, 2, 4}, armnn::DataType::Float32);
     const armnn::TensorInfo inputTensorInfo2 = armnn::TensorInfo({2, 1, 2, 4}, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo = armnn::TensorInfo({2, 1, 2, 4}, armnn::DataType::Boolean);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer2 = network->AddInputLayer(1);
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     armnn::IConnectableLayer* const equalLayer = network->AddEqualLayer(layerName.c_str());
     ARMNN_NO_DEPRECATE_WARN_END
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer1->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).SetTensorInfo(inputTensorInfo1);
     inputLayer2->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(1));
     inputLayer2->GetOutputSlot(0).SetTensorInfo(inputTensorInfo2);
     equalLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
     equalLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {inputTensorInfo1, inputTensorInfo2}, {outputTensorInfo});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [17/61]

BOOST_AUTO_TEST_CASE ( SerializeFill )

Definition at line 685 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), IOutputSlot::SetTensorInfo(), and armnn::Signed32.

 {
     const std::string layerName("fill");
     const armnn::TensorInfo inputInfo({4}, armnn::DataType::Signed32);
     const armnn::TensorInfo outputInfo({1, 3, 3, 1}, armnn::DataType::Float32);
 
     armnn::FillDescriptor descriptor(1.0f);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const fillLayer = network->AddFillLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(fillLayer->GetInputSlot(0));
     fillLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     fillLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::FillDescriptor> verifier(layerName, {inputInfo}, {outputInfo}, descriptor);
 
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [18/61]

BOOST_AUTO_TEST_CASE ( SerializeFloor )

Definition at line 712 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("floor");
     const armnn::TensorInfo info({4,4}, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const floorLayer = network->AddFloorLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(floorLayer->GetInputSlot(0));
     floorLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     floorLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [19/61]

BOOST_AUTO_TEST_CASE ( SerializeFullyConnected )

Definition at line 735 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptorAndConstants< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), FullyConnectedDescriptor::m_BiasEnabled, FullyConnectedDescriptor::m_TransposeWeightMatrix, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("fullyConnected");
     const armnn::TensorInfo inputInfo ({ 2, 5, 1, 1 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 2, 3 }, armnn::DataType::Float32);
 
     const armnn::TensorInfo weightsInfo({ 5, 3 }, armnn::DataType::Float32);
     const armnn::TensorInfo biasesInfo ({ 3 }, armnn::DataType::Float32);
     std::vector<float> weightsData = GenerateRandomData<float>(weightsInfo.GetNumElements());
     std::vector<float> biasesData  = GenerateRandomData<float>(biasesInfo.GetNumElements());
     armnn::ConstTensor weights(weightsInfo, weightsData);
     armnn::ConstTensor biases(biasesInfo, biasesData);
 
     armnn::FullyConnectedDescriptor descriptor;
     descriptor.m_BiasEnabled = true;
     descriptor.m_TransposeWeightMatrix = false;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const fullyConnectedLayer =
         network->AddFullyConnectedLayer(descriptor,
                                         weights,
                                         armnn::Optional<armnn::ConstTensor>(biases),
                                         layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(fullyConnectedLayer->GetInputSlot(0));
     fullyConnectedLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     fullyConnectedLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor> constants {weights, biases};
     LayerVerifierBaseWithDescriptorAndConstants<armnn::FullyConnectedDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [20/61]

BOOST_AUTO_TEST_CASE ( SerializeGather )

Definition at line 776 of file SerializerTests.cpp.

References IOutputSlot::Connect(), armnn::Constant, INetwork::Create(), DeserializeNetwork(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, GatherDescriptor::m_Axis, armnn::Output, armnn::QAsymmU8, SerializeNetwork(), IOutputSlot::SetTensorInfo(), and armnn::Signed32.

 {
     using GatherDescriptor = armnn::GatherDescriptor;
     class GatherLayerVerifier : public LayerVerifierBaseWithDescriptor<GatherDescriptor>
     {
     public:
         GatherLayerVerifier(const std::string& layerName,
                             const std::vector<armnn::TensorInfo>& inputInfos,
                             const std::vector<armnn::TensorInfo>& outputInfos,
                             const GatherDescriptor& descriptor)
             : LayerVerifierBaseWithDescriptor<GatherDescriptor>(layerName, inputInfos, outputInfos, descriptor) {}
 
         void ExecuteStrategy(const armnn::IConnectableLayer* layer,
                              const armnn::BaseDescriptor& descriptor,
                              const std::vector<armnn::ConstTensor>& constants,
                              const char* name,
                              const armnn::LayerBindingId id = 0) override
         {
             armnn::IgnoreUnused(constants, id);
             switch (layer->GetType())
             {
                 case armnn::LayerType::Input: break;
                 case armnn::LayerType::Output: break;
                 case armnn::LayerType::Constant: break;
                 default:
                 {
                     VerifyNameAndConnections(layer, name);
                     const GatherDescriptor& layerDescriptor = static_cast<const GatherDescriptor&>(descriptor);
                     BOOST_CHECK(layerDescriptor.m_Axis == m_Descriptor.m_Axis);
                 }
             }
         }
     };
 
     const std::string layerName("gather");
     armnn::TensorInfo paramsInfo({ 8 }, armnn::DataType::QAsymmU8);
     armnn::TensorInfo outputInfo({ 3 }, armnn::DataType::QAsymmU8);
     const armnn::TensorInfo indicesInfo({ 3 }, armnn::DataType::Signed32);
     GatherDescriptor descriptor;
     descriptor.m_Axis = 1;
 
     paramsInfo.SetQuantizationScale(1.0f);
     paramsInfo.SetQuantizationOffset(0);
     outputInfo.SetQuantizationScale(1.0f);
     outputInfo.SetQuantizationOffset(0);
 
     const std::vector<int32_t>& indicesData = {7, 6, 5};
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer *const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer *const constantLayer =
             network->AddConstantLayer(armnn::ConstTensor(indicesInfo, indicesData));
     armnn::IConnectableLayer *const gatherLayer = network->AddGatherLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer *const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(gatherLayer->GetInputSlot(0));
     constantLayer->GetOutputSlot(0).Connect(gatherLayer->GetInputSlot(1));
     gatherLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(paramsInfo);
     constantLayer->GetOutputSlot(0).SetTensorInfo(indicesInfo);
     gatherLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     GatherLayerVerifier verifier(layerName, {paramsInfo, indicesInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [21/61]

BOOST_AUTO_TEST_CASE ( SerializeGreaterDeprecated )

Definition at line 850 of file SerializerTests.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, armnn::Boolean, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("greater");
 
     const armnn::TensorShape shape{2, 1, 2, 4};
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     armnn::IConnectableLayer* const equalLayer = network->AddGreaterLayer(layerName.c_str());
     ARMNN_NO_DEPRECATE_WARN_END
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(equalLayer->GetInputSlot(1));
     equalLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(inputInfo);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(inputInfo);
     equalLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, { inputInfo, inputInfo }, { outputInfo });
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [22/61]

BOOST_AUTO_TEST_CASE ( SerializeInstanceNormalization )

Definition at line 883 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, InstanceNormalizationDescriptor::m_Gamma, armnn::NHWC, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("instanceNormalization");
     const armnn::TensorInfo info({ 1, 2, 1, 5 }, armnn::DataType::Float32);
 
     armnn::InstanceNormalizationDescriptor descriptor;
     descriptor.m_Gamma      = 1.1f;
     descriptor.m_Beta       = 0.1f;
     descriptor.m_Eps        = 0.0001f;
     descriptor.m_DataLayout = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer        = network->AddInputLayer(0);
     armnn::IConnectableLayer* const instanceNormLayer =
         network->AddInstanceNormalizationLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer       = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(instanceNormLayer->GetInputSlot(0));
     instanceNormLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     instanceNormLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::InstanceNormalizationDescriptor> verifier(
             layerName, {info}, {info}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [23/61]

BOOST_AUTO_TEST_CASE ( SerializeL2Normalization )

Definition at line 914 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, L2NormalizationDescriptor::m_DataLayout, armnn::NCHW, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string l2NormLayerName("l2Normalization");
     const armnn::TensorInfo info({1, 2, 1, 5}, armnn::DataType::Float32);
 
     armnn::L2NormalizationDescriptor desc;
     desc.m_DataLayout = armnn::DataLayout::NCHW;
     desc.m_Eps = 0.0001f;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const l2NormLayer = network->AddL2NormalizationLayer(desc, l2NormLayerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(l2NormLayer->GetInputSlot(0));
     l2NormLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     l2NormLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::L2NormalizationDescriptor> verifier(
             l2NormLayerName, {info}, {info}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [24/61]

BOOST_AUTO_TEST_CASE ( EnsureL2NormalizationBackwardCompatibility )

Definition at line 942 of file SerializerTests.cpp.

References DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, L2NormalizationDescriptor::m_DataLayout, and armnn::NCHW.

 {
     // The hex data below is a flat buffer containing a simple network with one input
     // a L2Normalization layer and an output layer with dimensions as per the tensor infos below.
     //
     // This test verifies that we can still read back these old style
     // models without the normalization epsilon value.
     const std::vector<uint8_t> l2NormalizationModel =
     {
         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x0A, 0x00,
         0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
         0x3C, 0x01, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xE8, 0xFE, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x0B,
         0x04, 0x00, 0x00, 0x00, 0xD6, 0xFE, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x08, 0x00,
         0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x9E, 0xFF, 0xFF, 0xFF, 0x02, 0x00, 0x00, 0x00,
         0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x4C, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
         0x00, 0x20, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00,
         0x20, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x06, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x0E, 0x00, 0x18, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x14, 0x00, 0x0E, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x20, 0x00,
         0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x6C, 0x32, 0x4E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x69, 0x7A, 0x61, 0x74,
         0x69, 0x6F, 0x6E, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00,
         0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
         0x52, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
         0x08, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
         0x04, 0x00, 0x00, 0x00, 0xF6, 0xFF, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x0A, 0x00,
         0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00,
         0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0A, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x08, 0x00,
         0x07, 0x00, 0x0C, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
         0x05, 0x00, 0x00, 0x00, 0x00
     };
 
     armnn::INetworkPtr deserializedNetwork =
         DeserializeNetwork(std::string(l2NormalizationModel.begin(), l2NormalizationModel.end()));
     BOOST_CHECK(deserializedNetwork);
 
     const std::string layerName("l2Normalization");
     const armnn::TensorInfo inputInfo = armnn::TensorInfo({1, 2, 1, 5}, armnn::DataType::Float32);
 
     armnn::L2NormalizationDescriptor desc;
     desc.m_DataLayout = armnn::DataLayout::NCHW;
     // Since this variable does not exist in the l2NormalizationModel dump, the default value will be loaded
     desc.m_Eps = 1e-12f;
 
     LayerVerifierBaseWithDescriptor<armnn::L2NormalizationDescriptor> verifier(
             layerName, {inputInfo}, {inputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [25/61]

BOOST_AUTO_TEST_CASE ( SerializeLogicalBinary )

Definition at line 999 of file SerializerTests.cpp.

References armnn::Boolean, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::LogicalAnd, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("logicalBinaryAnd");
 
     const armnn::TensorShape shape{2, 1, 2, 2};
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Boolean);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
 
     armnn::LogicalBinaryDescriptor descriptor(armnn::LogicalBinaryOperation::LogicalAnd);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0        = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1        = network->AddInputLayer(1);
     armnn::IConnectableLayer* const logicalBinaryLayer = network->AddLogicalBinaryLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer        = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(logicalBinaryLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(logicalBinaryLayer->GetInputSlot(1));
     logicalBinaryLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(inputInfo);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(inputInfo);
     logicalBinaryLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::LogicalBinaryDescriptor> verifier(
             layerName, { inputInfo, inputInfo }, { outputInfo }, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [26/61]

BOOST_AUTO_TEST_CASE ( SerializeLogicalUnary )

Definition at line 1032 of file SerializerTests.cpp.

References armnn::Boolean, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::LogicalNot, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("elementwiseUnaryLogicalNot");
 
     const armnn::TensorShape shape{2, 1, 2, 2};
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo(shape, armnn::DataType::Boolean);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo(shape, armnn::DataType::Boolean);
 
     armnn::ElementwiseUnaryDescriptor descriptor(armnn::UnaryOperation::LogicalNot);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const elementwiseUnaryLayer =
         network->AddElementwiseUnaryLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(elementwiseUnaryLayer->GetInputSlot(0));
     elementwiseUnaryLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     elementwiseUnaryLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
 
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ElementwiseUnaryDescriptor> verifier(
             layerName, { inputInfo }, { outputInfo }, descriptor);
 
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [27/61]

BOOST_AUTO_TEST_CASE ( SerializeLogSoftmax )

Definition at line 1065 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SoftmaxDescriptor::m_Beta, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("log_softmax");
     const armnn::TensorInfo info({1, 10}, armnn::DataType::Float32);
 
     armnn::LogSoftmaxDescriptor descriptor;
     descriptor.m_Beta = 1.0f;
     descriptor.m_Axis = -1;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer      = network->AddInputLayer(0);
     armnn::IConnectableLayer* const logSoftmaxLayer = network->AddLogSoftmaxLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer     = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(logSoftmaxLayer->GetInputSlot(0));
     logSoftmaxLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     logSoftmaxLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::LogSoftmaxDescriptor> verifier(layerName, {info}, {info}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [28/61]

BOOST_AUTO_TEST_CASE ( SerializeMaximum )

Definition at line 1092 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("maximum");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const maximumLayer = network->AddMaximumLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(maximumLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(maximumLayer->GetInputSlot(1));
     maximumLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
     maximumLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info, info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [29/61]

BOOST_AUTO_TEST_CASE ( SerializeMean )

Definition at line 1118 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), MeanDescriptor::m_Axis, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("mean");
     const armnn::TensorInfo inputInfo({1, 1, 3, 2}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({1, 1, 1, 2}, armnn::DataType::Float32);
 
     armnn::MeanDescriptor descriptor;
     descriptor.m_Axis = { 2 };
     descriptor.m_KeepDims = true;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer   = network->AddInputLayer(0);
     armnn::IConnectableLayer* const meanLayer = network->AddMeanLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer  = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(meanLayer->GetInputSlot(0));
     meanLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     meanLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::MeanDescriptor> verifier(layerName, {inputInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [30/61]

BOOST_AUTO_TEST_CASE ( SerializeMerge )

Definition at line 1146 of file SerializerTests.cpp.

References armnn::Concat, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::info, armnn::Input, armnn::Merge, armnn::Output, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("merge");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const mergeLayer = network->AddMergeLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(mergeLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(mergeLayer->GetInputSlot(1));
     mergeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
     mergeLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info, info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [31/61]

BOOST_AUTO_TEST_CASE ( SerializeMerger )

Definition at line 1216 of file SerializerTests.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, IOutputSlot::Connect(), INetwork::Create(), armnn::CreateDescriptorForConcatenation(), DeserializeNetwork(), armnn::Float32, IConnectableLayer::GetOutputSlot(), TensorInfo::GetShape(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("merger");
     const armnn::TensorInfo inputInfo = armnn::TensorInfo({2, 3, 2, 2}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({4, 3, 2, 2}, armnn::DataType::Float32);
 
     const std::vector<armnn::TensorShape> shapes({inputInfo.GetShape(), inputInfo.GetShape()});
 
     armnn::OriginsDescriptor descriptor =
         armnn::CreateDescriptorForConcatenation(shapes.begin(), shapes.end(), 0);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayerOne = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayerTwo = network->AddInputLayer(1);
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     armnn::IConnectableLayer* const mergerLayer = network->AddMergerLayer(descriptor, layerName.c_str());
     ARMNN_NO_DEPRECATE_WARN_END
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayerOne->GetOutputSlot(0).Connect(mergerLayer->GetInputSlot(0));
     inputLayerTwo->GetOutputSlot(0).Connect(mergerLayer->GetInputSlot(1));
     mergerLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayerOne->GetOutputSlot(0).SetTensorInfo(inputInfo);
     inputLayerTwo->GetOutputSlot(0).SetTensorInfo(inputInfo);
     mergerLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     std::string mergerLayerNetwork = SerializeNetwork(*network);
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(mergerLayerNetwork);
     BOOST_CHECK(deserializedNetwork);
 
     MergerLayerVerifier verifier(layerName, {inputInfo, inputInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [32/61]

BOOST_AUTO_TEST_CASE ( EnsureMergerLayerBackwardCompatibility )

Definition at line 1251 of file SerializerTests.cpp.

References armnn::CreateDescriptorForConcatenation(), DeserializeNetwork(), armnn::Float32, and TensorInfo::GetShape().

 {
     // The hex data below is a flat buffer containing a simple network with two inputs
     // a merger layer (now deprecated) and an output layer with dimensions as per the tensor infos below.
     //
     // This test verifies that we can still read back these old style
     // models replacing the MergerLayers with ConcatLayers with the same parameters.
     const std::vector<uint8_t> mergerModel =
     {
         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x0A, 0x00,
         0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
         0x38, 0x02, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
         0xF4, 0xFD, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x0B, 0x04, 0x00, 0x00, 0x00, 0x92, 0xFE, 0xFF, 0xFF, 0x04, 0x00,
         0x00, 0x00, 0x9A, 0xFE, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x7E, 0xFE, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
         0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0xF8, 0xFE, 0xFF, 0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0xFE, 0xFF, 0xFF, 0x00, 0x00,
         0x00, 0x1F, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00,
         0x68, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00,
         0x0C, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
         0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x22, 0xFF, 0xFF, 0xFF, 0x04, 0x00,
         0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x3E, 0xFF, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xFF, 0xFF, 0xFF,
         0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1C, 0x00,
         0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x6D, 0x65, 0x72, 0x67, 0x65, 0x72, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
         0x5C, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34, 0xFF,
         0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x92, 0xFE, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00,
         0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0E, 0x00,
         0x07, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x06, 0x00, 0x08, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0E, 0x00,
         0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x0E, 0x00, 0x18, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x14, 0x00, 0x0E, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
         0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00,
         0x00, 0x00, 0x66, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
         0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
         0x04, 0x00, 0x00, 0x00, 0xF6, 0xFF, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x0A, 0x00,
         0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x14, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00,
         0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0A, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x08, 0x00,
         0x07, 0x00, 0x0C, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
         0x02, 0x00, 0x00, 0x00
     };
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(std::string(mergerModel.begin(), mergerModel.end()));
     BOOST_CHECK(deserializedNetwork);
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo({ 2, 3, 2, 2 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({ 4, 3, 2, 2 }, armnn::DataType::Float32);
 
     const std::vector<armnn::TensorShape> shapes({inputInfo.GetShape(), inputInfo.GetShape()});
 
     armnn::OriginsDescriptor descriptor =
             armnn::CreateDescriptorForConcatenation(shapes.begin(), shapes.end(), 0);
 
     MergerLayerVerifier verifier("merger", { inputInfo, inputInfo }, { outputInfo }, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [33/61]

BOOST_AUTO_TEST_CASE ( SerializeConcat )

Definition at line 1320 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), armnn::CreateDescriptorForConcatenation(), DeserializeNetwork(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), TensorInfo::GetShape(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("concat");
     const armnn::TensorInfo inputInfo = armnn::TensorInfo({2, 3, 2, 2}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({4, 3, 2, 2}, armnn::DataType::Float32);
 
     const std::vector<armnn::TensorShape> shapes({inputInfo.GetShape(), inputInfo.GetShape()});
 
     armnn::OriginsDescriptor descriptor =
         armnn::CreateDescriptorForConcatenation(shapes.begin(), shapes.end(), 0);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayerOne = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayerTwo = network->AddInputLayer(1);
     armnn::IConnectableLayer* const concatLayer = network->AddConcatLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayerOne->GetOutputSlot(0).Connect(concatLayer->GetInputSlot(0));
     inputLayerTwo->GetOutputSlot(0).Connect(concatLayer->GetInputSlot(1));
     concatLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayerOne->GetOutputSlot(0).SetTensorInfo(inputInfo);
     inputLayerTwo->GetOutputSlot(0).SetTensorInfo(inputInfo);
     concatLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     std::string concatLayerNetwork = SerializeNetwork(*network);
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(concatLayerNetwork);
     BOOST_CHECK(deserializedNetwork);
 
     // NOTE: using the MergerLayerVerifier to ensure that it is a concat layer and not a
     //       merger layer that gets placed into the graph.
     MergerLayerVerifier verifier(layerName, {inputInfo, inputInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [34/61]

BOOST_AUTO_TEST_CASE ( SerializeMinimum )

Definition at line 1355 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("minimum");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const minimumLayer = network->AddMinimumLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(minimumLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(minimumLayer->GetInputSlot(1));
     minimumLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
     minimumLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info, info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [35/61]

BOOST_AUTO_TEST_CASE ( SerializeMultiplication )

Definition at line 1381 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("multiplication");
     const armnn::TensorInfo info({ 1, 5, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const multiplicationLayer = network->AddMultiplicationLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(multiplicationLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(multiplicationLayer->GetInputSlot(1));
     multiplicationLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
     multiplicationLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info, info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [36/61]

BOOST_AUTO_TEST_CASE ( SerializePrelu )

Definition at line 1407 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("prelu");
 
     armnn::TensorInfo inputTensorInfo ({ 4, 1, 2 }, armnn::DataType::Float32);
     armnn::TensorInfo alphaTensorInfo ({ 5, 4, 3, 1 }, armnn::DataType::Float32);
     armnn::TensorInfo outputTensorInfo({ 5, 4, 3, 2 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const alphaLayer = network->AddInputLayer(1);
     armnn::IConnectableLayer* const preluLayer = network->AddPreluLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(preluLayer->GetInputSlot(0));
     alphaLayer->GetOutputSlot(0).Connect(preluLayer->GetInputSlot(1));
     preluLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     alphaLayer->GetOutputSlot(0).SetTensorInfo(alphaTensorInfo);
     preluLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {inputTensorInfo, alphaTensorInfo}, {outputTensorInfo});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [37/61]

BOOST_AUTO_TEST_CASE ( SerializeNormalization )

Definition at line 1436 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, NormalizationDescriptor::m_DataLayout, armnn::NCHW, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("normalization");
     const armnn::TensorInfo info({2, 1, 2, 2}, armnn::DataType::Float32);
 
     armnn::NormalizationDescriptor desc;
     desc.m_DataLayout = armnn::DataLayout::NCHW;
     desc.m_NormSize = 3;
     desc.m_Alpha = 1;
     desc.m_Beta = 1;
     desc.m_K = 1;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const normalizationLayer = network->AddNormalizationLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(normalizationLayer->GetInputSlot(0));
     normalizationLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     normalizationLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::NormalizationDescriptor> verifier(layerName, {info}, {info}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [38/61]

BOOST_AUTO_TEST_CASE ( SerializePad )

Definition at line 1466 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("pad");
     const armnn::TensorInfo inputTensorInfo = armnn::TensorInfo({1, 2, 3, 4}, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo = armnn::TensorInfo({1, 3, 5, 7}, armnn::DataType::Float32);
 
     armnn::PadDescriptor desc({{0, 0}, {1, 0}, {1, 1}, {1, 2}});
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const padLayer = network->AddPadLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(padLayer->GetInputSlot(0));
     padLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     padLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::PadDescriptor> verifier(layerName,
                                                                    {inputTensorInfo},
                                                                    {outputTensorInfo},
                                                                    desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [39/61]

BOOST_AUTO_TEST_CASE ( EnsurePadBackwardCompatibility )

Definition at line 1495 of file SerializerTests.cpp.

References DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), and armnn::Float32.

 {
     // The PadDescriptor is being extended with a float PadValue (so a value other than 0
     // can be used to pad the tensor.
     //
     // This test contains a binary representation of a simple input->pad->output network
     // prior to this change to test that the descriptor has been updated in a backward
     // compatible way with respect to Deserialization of older binary dumps
     const std::vector<uint8_t> padModel =
     {
         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x0A, 0x00,
         0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
         0x54, 0x01, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xD0, 0xFE, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x0B,
         0x04, 0x00, 0x00, 0x00, 0x96, 0xFF, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x9E, 0xFF, 0xFF, 0xFF, 0x04, 0x00,
         0x00, 0x00, 0x72, 0xFF, 0xFF, 0xFF, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
         0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
         0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x24, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x16, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00,
         0x0E, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x06, 0x00, 0x08, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x0E, 0x00, 0x18, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x14, 0x00, 0x0E, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00,
         0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x70, 0x61, 0x64, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00,
         0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x52, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00,
         0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x08, 0x00, 0x08, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x00, 0xF6, 0xFF, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x06, 0x00, 0x0A, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x0E, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x0E, 0x00, 0x00, 0x00,
         0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
         0x08, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x0A, 0x00, 0x10, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0C, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
         0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
         0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00
     };
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(std::string(padModel.begin(), padModel.end()));
     BOOST_CHECK(deserializedNetwork);
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo({ 1, 2, 3, 4 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({ 1, 3, 5, 7 }, armnn::DataType::Float32);
 
     armnn::PadDescriptor descriptor({{ 0, 0 }, { 1, 0 }, { 1, 1 }, { 1, 2 }});
 
     LayerVerifierBaseWithDescriptor<armnn::PadDescriptor> verifier("pad", { inputInfo }, { outputInfo }, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [40/61]

BOOST_AUTO_TEST_CASE ( SerializePermute )

Definition at line 1549 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("permute");
     const armnn::TensorInfo inputTensorInfo({4, 3, 2, 1}, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo({1, 2, 3, 4}, armnn::DataType::Float32);
 
     armnn::PermuteDescriptor descriptor(armnn::PermutationVector({3, 2, 1, 0}));
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const permuteLayer = network->AddPermuteLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(permuteLayer->GetInputSlot(0));
     permuteLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     permuteLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::PermuteDescriptor> verifier(
             layerName, {inputTensorInfo}, {outputTensorInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [41/61]

BOOST_AUTO_TEST_CASE ( SerializePooling2d )

Definition at line 1576 of file SerializerTests.cpp.

References armnn::Average, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), armnn::Exclude, LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, armnn::Floor, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), Pooling2dDescriptor::m_DataLayout, armnn::NHWC, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("pooling2d");
     const armnn::TensorInfo inputInfo({1, 2, 2, 1}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({1, 1, 1, 1}, armnn::DataType::Float32);
 
     armnn::Pooling2dDescriptor desc;
     desc.m_DataLayout          = armnn::DataLayout::NHWC;
     desc.m_PadTop              = 0;
     desc.m_PadBottom           = 0;
     desc.m_PadLeft             = 0;
     desc.m_PadRight            = 0;
     desc.m_PoolType            = armnn::PoolingAlgorithm::Average;
     desc.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
     desc.m_PaddingMethod       = armnn::PaddingMethod::Exclude;
     desc.m_PoolHeight          = 2;
     desc.m_PoolWidth           = 2;
     desc.m_StrideX             = 2;
     desc.m_StrideY             = 2;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const pooling2dLayer = network->AddPooling2dLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(pooling2dLayer->GetInputSlot(0));
     pooling2dLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     pooling2dLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::Pooling2dDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [42/61]

BOOST_AUTO_TEST_CASE ( SerializeQuantize )

Definition at line 1615 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("quantize");
     const armnn::TensorInfo info({ 1, 2, 2, 3 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const quantizeLayer = network->AddQuantizeLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(quantizeLayer->GetInputSlot(0));
     quantizeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     quantizeLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [43/61]

BOOST_AUTO_TEST_CASE ( SerializeRank )

Definition at line 1638 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), IOutputSlot::SetTensorInfo(), and armnn::Signed32.

 {
     const std::string layerName("rank");
     const armnn::TensorInfo inputInfo({1, 9}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({1}, armnn::DataType::Signed32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const rankLayer = network->AddRankLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(rankLayer->GetInputSlot(0));
     rankLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     rankLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [44/61]

BOOST_AUTO_TEST_CASE ( SerializeReduceSum )

Definition at line 1662 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), ReduceDescriptor::m_vAxis, SerializeNetwork(), IOutputSlot::SetTensorInfo(), and armnn::Sum.

 {
     const std::string layerName("Reduce_Sum");
     const armnn::TensorInfo inputInfo({1, 1, 3, 2}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({1, 1, 1, 2}, armnn::DataType::Float32);
 
     armnn::ReduceDescriptor descriptor;
     descriptor.m_vAxis = { 2 };
     descriptor.m_ReduceOperation = armnn::ReduceOperation::Sum;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer   = network->AddInputLayer(0);
     armnn::IConnectableLayer* const reduceSumLayer = network->AddReduceLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer  = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(reduceSumLayer->GetInputSlot(0));
     reduceSumLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     reduceSumLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ReduceDescriptor> verifier(layerName, {inputInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [45/61]

BOOST_AUTO_TEST_CASE ( SerializeReshape )

Definition at line 1690 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("reshape");
     const armnn::TensorInfo inputInfo({1, 9}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({3, 3}, armnn::DataType::Float32);
 
     armnn::ReshapeDescriptor descriptor({3, 3});
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const reshapeLayer = network->AddReshapeLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(reshapeLayer->GetInputSlot(0));
     reshapeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     reshapeLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ReshapeDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [46/61]

BOOST_AUTO_TEST_CASE ( SerializeResize )

Definition at line 1717 of file SerializerTests.cpp.

References armnn::Bilinear, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, ResizeDescriptor::m_AlignCorners, ResizeDescriptor::m_DataLayout, ResizeDescriptor::m_HalfPixelCenters, ResizeDescriptor::m_Method, ResizeDescriptor::m_TargetHeight, ResizeDescriptor::m_TargetWidth, armnn::NearestNeighbor, armnn::Output, armnn::Resize, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("resize");
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo({1, 3, 5, 5}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({1, 3, 2, 4}, armnn::DataType::Float32);
 
     armnn::ResizeDescriptor desc;
     desc.m_TargetWidth  = 4;
     desc.m_TargetHeight = 2;
     desc.m_Method       = armnn::ResizeMethod::NearestNeighbor;
     desc.m_AlignCorners = true;
     desc.m_HalfPixelCenters = true;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const resizeLayer = network->AddResizeLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(resizeLayer->GetInputSlot(0));
     resizeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     resizeLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ResizeDescriptor> verifier(layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [47/61]

BOOST_AUTO_TEST_CASE ( SerializeResizeBilinear )

Definition at line 1794 of file SerializerTests.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), armnn::Float32, IConnectableLayer::GetOutputSlot(), ResizeBilinearDescriptor::m_TargetWidth, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("resizeBilinear");
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo({1, 3, 5, 5}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({1, 3, 2, 4}, armnn::DataType::Float32);
 
     armnn::ResizeBilinearDescriptor desc;
     desc.m_TargetWidth  = 4u;
     desc.m_TargetHeight = 2u;
     desc.m_AlignCorners = true;
     desc.m_HalfPixelCenters = true;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     armnn::IConnectableLayer* const resizeLayer = network->AddResizeBilinearLayer(desc, layerName.c_str());
     ARMNN_NO_DEPRECATE_WARN_END
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(resizeLayer->GetInputSlot(0));
     resizeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     resizeLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     ResizeBilinearLayerVerifier verifier(layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [48/61]

BOOST_AUTO_TEST_CASE ( EnsureResizeBilinearBackwardCompatibility )

Definition at line 1826 of file SerializerTests.cpp.

References DeserializeNetwork(), armnn::Float32, and ResizeBilinearDescriptor::m_TargetWidth.

 {
     // The hex data below is a flat buffer containing a simple network with an input,
     // a ResizeBilinearLayer (now deprecated) and an output
     //
     // This test verifies that we can still deserialize this old-style model by replacing
     // the ResizeBilinearLayer with an equivalent ResizeLayer
     const std::vector<uint8_t> resizeBilinearModel =
     {
         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x0A, 0x00,
         0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
         0x50, 0x01, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xD4, 0xFE, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x0B,
         0x04, 0x00, 0x00, 0x00, 0xC2, 0xFE, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x08, 0x00,
         0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x8A, 0xFF, 0xFF, 0xFF, 0x02, 0x00, 0x00, 0x00,
         0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x38, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
         0x00, 0x1A, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0E, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00,
         0x34, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x12, 0x00, 0x08, 0x00, 0x0C, 0x00,
         0x07, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x0E, 0x00, 0x18, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x14, 0x00, 0x0E, 0x00,
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00,
         0x20, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x72, 0x65, 0x73, 0x69, 0x7A, 0x65, 0x42, 0x69, 0x6C, 0x69,
         0x6E, 0x65, 0x61, 0x72, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
         0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00,
         0x00, 0x00, 0x52, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00,
         0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x09, 0x04, 0x00, 0x00, 0x00, 0xF6, 0xFF, 0xFF, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
         0x0A, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x14, 0x00,
         0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
         0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0A, 0x00,
         0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x10, 0x00,
         0x08, 0x00, 0x07, 0x00, 0x0C, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00,
         0x00, 0x00, 0x05, 0x00, 0x00, 0x00
     };
 
     armnn::INetworkPtr deserializedNetwork =
         DeserializeNetwork(std::string(resizeBilinearModel.begin(), resizeBilinearModel.end()));
     BOOST_CHECK(deserializedNetwork);
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo({1, 3, 5, 5}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({1, 3, 2, 4}, armnn::DataType::Float32);
 
     armnn::ResizeBilinearDescriptor descriptor;
     descriptor.m_TargetWidth  = 4u;
     descriptor.m_TargetHeight = 2u;
 
     ResizeBilinearLayerVerifier verifier("resizeBilinear", { inputInfo }, { outputInfo }, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [49/61]

BOOST_AUTO_TEST_CASE ( SerializeSlice )

Definition at line 1882 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName{"slice"};
 
     const armnn::TensorInfo inputInfo  = armnn::TensorInfo({3, 2, 3, 1}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({2, 2, 2, 1}, armnn::DataType::Float32);
 
     armnn::SliceDescriptor descriptor({ 0, 0, 1, 0}, {2, 2, 2, 1});
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
 
     armnn::IConnectableLayer* const inputLayer  = network->AddInputLayer(0);
     armnn::IConnectableLayer* const sliceLayer  = network->AddSliceLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(sliceLayer->GetInputSlot(0));
     sliceLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     sliceLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::SliceDescriptor> verifier(layerName, {inputInfo}, {outputInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [50/61]

BOOST_AUTO_TEST_CASE ( SerializeSoftmax )

Definition at line 1910 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SoftmaxDescriptor::m_Beta, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("softmax");
     const armnn::TensorInfo info({1, 10}, armnn::DataType::Float32);
 
     armnn::SoftmaxDescriptor descriptor;
     descriptor.m_Beta = 1.0f;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer   = network->AddInputLayer(0);
     armnn::IConnectableLayer* const softmaxLayer = network->AddSoftmaxLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer  = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(softmaxLayer->GetInputSlot(0));
     softmaxLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     softmaxLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::SoftmaxDescriptor> verifier(layerName, {info}, {info}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [51/61]

BOOST_AUTO_TEST_CASE ( SerializeSpaceToBatchNd )

Definition at line 1936 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SpaceToBatchNdDescriptor::m_DataLayout, armnn::NCHW, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("spaceToBatchNd");
     const armnn::TensorInfo inputInfo({2, 1, 2, 4}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({8, 1, 1, 3}, armnn::DataType::Float32);
 
     armnn::SpaceToBatchNdDescriptor desc;
     desc.m_DataLayout = armnn::DataLayout::NCHW;
     desc.m_BlockShape = {2, 2};
     desc.m_PadList = {{0, 0}, {2, 0}};
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const spaceToBatchNdLayer = network->AddSpaceToBatchNdLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(spaceToBatchNdLayer->GetInputSlot(0));
     spaceToBatchNdLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     spaceToBatchNdLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::SpaceToBatchNdDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [52/61]

BOOST_AUTO_TEST_CASE ( SerializeSpaceToDepth )

Definition at line 1966 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SpaceToDepthDescriptor::m_BlockSize, armnn::NHWC, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("spaceToDepth");
 
     const armnn::TensorInfo inputInfo ({ 1, 16, 8,  3 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 1,  8, 4, 12 }, armnn::DataType::Float32);
 
     armnn::SpaceToDepthDescriptor desc;
     desc.m_BlockSize  = 2;
     desc.m_DataLayout = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer        = network->AddInputLayer(0);
     armnn::IConnectableLayer* const spaceToDepthLayer = network->AddSpaceToDepthLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer       = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(spaceToDepthLayer->GetInputSlot(0));
     spaceToDepthLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     spaceToDepthLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::SpaceToDepthDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [53/61]

BOOST_AUTO_TEST_CASE ( SerializeSplitter )

Definition at line 1996 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), IOutputSlot::SetTensorInfo(), ViewsDescriptor::SetViewOriginCoord(), and ViewsDescriptor::SetViewSize().

 {
     const unsigned int numViews = 3;
     const unsigned int numDimensions = 4;
     const unsigned int inputShape[] = {1, 18, 4, 4};
     const unsigned int outputShape[] = {1, 6, 4, 4};
 
     // This is modelled on how the caffe parser sets up a splitter layer to partition an input along dimension one.
     unsigned int splitterDimSizes[4] = {static_cast<unsigned int>(inputShape[0]),
                                         static_cast<unsigned int>(inputShape[1]),
                                         static_cast<unsigned int>(inputShape[2]),
                                         static_cast<unsigned int>(inputShape[3])};
     splitterDimSizes[1] /= numViews;
     armnn::ViewsDescriptor desc(numViews, numDimensions);
 
     for (unsigned int g = 0; g < numViews; ++g)
     {
         desc.SetViewOriginCoord(g, 1, splitterDimSizes[1] * g);
 
         for (unsigned int dimIdx=0; dimIdx < 4; dimIdx++)
         {
             desc.SetViewSize(g, dimIdx, splitterDimSizes[dimIdx]);
         }
     }
 
     const std::string layerName("splitter");
     const armnn::TensorInfo inputInfo(numDimensions, inputShape, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo(numDimensions, outputShape, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const splitterLayer = network->AddSplitterLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer0 = network->AddOutputLayer(0);
     armnn::IConnectableLayer* const outputLayer1 = network->AddOutputLayer(1);
     armnn::IConnectableLayer* const outputLayer2 = network->AddOutputLayer(2);
 
     inputLayer->GetOutputSlot(0).Connect(splitterLayer->GetInputSlot(0));
     splitterLayer->GetOutputSlot(0).Connect(outputLayer0->GetInputSlot(0));
     splitterLayer->GetOutputSlot(1).Connect(outputLayer1->GetInputSlot(0));
     splitterLayer->GetOutputSlot(2).Connect(outputLayer2->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     splitterLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
     splitterLayer->GetOutputSlot(1).SetTensorInfo(outputInfo);
     splitterLayer->GetOutputSlot(2).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::ViewsDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo, outputInfo, outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [54/61]

BOOST_AUTO_TEST_CASE ( SerializeStack )

Definition at line 2050 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("stack");
 
     armnn::TensorInfo inputTensorInfo ({4, 3, 5}, armnn::DataType::Float32);
     armnn::TensorInfo outputTensorInfo({4, 3, 2, 5}, armnn::DataType::Float32);
 
     armnn::StackDescriptor descriptor(2, 2, {4, 3, 5});
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer2 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const stackLayer = network->AddStackLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer1->GetOutputSlot(0).Connect(stackLayer->GetInputSlot(0));
     inputLayer2->GetOutputSlot(0).Connect(stackLayer->GetInputSlot(1));
     stackLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer1->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     inputLayer2->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     stackLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::StackDescriptor> verifier(
             layerName, {inputTensorInfo, inputTensorInfo}, {outputTensorInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [55/61]

BOOST_AUTO_TEST_CASE ( SerializeStandIn )

Definition at line 2081 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("standIn");
 
     armnn::TensorInfo tensorInfo({ 1u }, armnn::DataType::Float32);
     armnn::StandInDescriptor descriptor(2u, 2u);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0  = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1  = network->AddInputLayer(1);
     armnn::IConnectableLayer* const standInLayer = network->AddStandInLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer0 = network->AddOutputLayer(0);
     armnn::IConnectableLayer* const outputLayer1 = network->AddOutputLayer(1);
 
     inputLayer0->GetOutputSlot(0).Connect(standInLayer->GetInputSlot(0));
     inputLayer0->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     inputLayer1->GetOutputSlot(0).Connect(standInLayer->GetInputSlot(1));
     inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     standInLayer->GetOutputSlot(0).Connect(outputLayer0->GetInputSlot(0));
     standInLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     standInLayer->GetOutputSlot(1).Connect(outputLayer1->GetInputSlot(0));
     standInLayer->GetOutputSlot(1).SetTensorInfo(tensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::StandInDescriptor> verifier(
             layerName, { tensorInfo, tensorInfo }, { tensorInfo, tensorInfo }, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [56/61]

BOOST_AUTO_TEST_CASE ( SerializeStridedSlice )

Definition at line 2115 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), StridedSliceDescriptor::m_EndMask, armnn::NCHW, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("stridedSlice");
     const armnn::TensorInfo inputInfo = armnn::TensorInfo({3, 2, 3, 1}, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo = armnn::TensorInfo({3, 1}, armnn::DataType::Float32);
 
     armnn::StridedSliceDescriptor desc({0, 0, 1, 0}, {1, 1, 1, 1}, {1, 1, 1, 1});
     desc.m_EndMask = (1 << 4) - 1;
     desc.m_ShrinkAxisMask = (1 << 1) | (1 << 2);
     desc.m_DataLayout = armnn::DataLayout::NCHW;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const stridedSliceLayer = network->AddStridedSliceLayer(desc, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(stridedSliceLayer->GetInputSlot(0));
     stridedSliceLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     stridedSliceLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::StridedSliceDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, desc);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [57/61]

BOOST_AUTO_TEST_CASE ( SerializeSubtraction )

Definition at line 2145 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBase::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), armnn::info, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("subtraction");
     const armnn::TensorInfo info({ 1, 4 }, armnn::DataType::Float32);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer0 = network->AddInputLayer(0);
     armnn::IConnectableLayer* const inputLayer1 = network->AddInputLayer(1);
     armnn::IConnectableLayer* const subtractionLayer = network->AddSubtractionLayer(layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(subtractionLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(subtractionLayer->GetInputSlot(1));
     subtractionLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(info);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(info);
     subtractionLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBase verifier(layerName, {info, info}, {info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [58/61]

BOOST_AUTO_TEST_CASE ( SerializeSwitch )

Definition at line 2171 of file SerializerTests.cpp.

References IOutputSlot::Connect(), armnn::Constant, INetwork::Create(), DeserializeNetwork(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::info, armnn::Input, armnn::Output, SerializeNetwork(), IOutputSlot::SetTensorInfo(), and armnn::Switch.

 {
     class SwitchLayerVerifier : public LayerVerifierBase
     {
     public:
         SwitchLayerVerifier(const std::string& layerName,
                             const std::vector<armnn::TensorInfo>& inputInfos,
                             const std::vector<armnn::TensorInfo>& outputInfos)
                 : LayerVerifierBase(layerName, inputInfos, outputInfos) {}
 
         void ExecuteStrategy(const armnn::IConnectableLayer* layer,
                              const armnn::BaseDescriptor& descriptor,
                              const std::vector<armnn::ConstTensor>& constants,
                              const char* name,
                              const armnn::LayerBindingId id = 0) override
         {
             armnn::IgnoreUnused(descriptor, constants, id);
             switch (layer->GetType())
             {
                 case armnn::LayerType::Input: break;
                 case armnn::LayerType::Output: break;
                 case armnn::LayerType::Constant: break;
                 case armnn::LayerType::Switch:
                 {
                     VerifyNameAndConnections(layer, name);
                     break;
                 }
                 default:
                 {
                     throw armnn::Exception("Unexpected layer type in Switch test model");
                 }
             }
         }
     };
 
     const std::string layerName("switch");
     const armnn::TensorInfo info({ 1, 4 }, armnn::DataType::Float32);
 
     std::vector<float> constantData = GenerateRandomData<float>(info.GetNumElements());
     armnn::ConstTensor constTensor(info, constantData);
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const constantLayer = network->AddConstantLayer(constTensor, "constant");
     armnn::IConnectableLayer* const switchLayer = network->AddSwitchLayer(layerName.c_str());
     armnn::IConnectableLayer* const trueOutputLayer = network->AddOutputLayer(0);
     armnn::IConnectableLayer* const falseOutputLayer = network->AddOutputLayer(1);
 
     inputLayer->GetOutputSlot(0).Connect(switchLayer->GetInputSlot(0));
     constantLayer->GetOutputSlot(0).Connect(switchLayer->GetInputSlot(1));
     switchLayer->GetOutputSlot(0).Connect(trueOutputLayer->GetInputSlot(0));
     switchLayer->GetOutputSlot(1).Connect(falseOutputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     constantLayer->GetOutputSlot(0).SetTensorInfo(info);
     switchLayer->GetOutputSlot(0).SetTensorInfo(info);
     switchLayer->GetOutputSlot(1).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     SwitchLayerVerifier verifier(layerName, {info, info}, {info, info});
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [59/61]

BOOST_AUTO_TEST_CASE ( SerializeTranspose )

Definition at line 2236 of file SerializerTests.cpp.

References IOutputSlot::Connect(), INetwork::Create(), DeserializeNetwork(), LayerVerifierBaseWithDescriptor< Descriptor >::ExecuteStrategy(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     const std::string layerName("transpose");
     const armnn::TensorInfo inputTensorInfo({4, 3, 2, 1}, armnn::DataType::Float32);
     const armnn::TensorInfo outputTensorInfo({1, 2, 3, 4}, armnn::DataType::Float32);
 
     armnn::TransposeDescriptor descriptor(armnn::PermutationVector({3, 2, 1, 0}));
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
     armnn::IConnectableLayer* const transposeLayer = network->AddTransposeLayer(descriptor, layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(transposeLayer->GetInputSlot(0));
     transposeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
     transposeLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     LayerVerifierBaseWithDescriptor<armnn::TransposeDescriptor> verifier(
             layerName, {inputTensorInfo}, {outputTensorInfo}, descriptor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [60/61]

BOOST_AUTO_TEST_CASE ( SerializeTransposeConvolution2d )

Definition at line 2263 of file SerializerTests.cpp.

 {
     const std::string layerName("transposeConvolution2d");
     const armnn::TensorInfo inputInfo ({ 1, 7, 7, 1 }, armnn::DataType::Float32);
     const armnn::TensorInfo outputInfo({ 1, 9, 9, 1 }, armnn::DataType::Float32);
 
     const armnn::TensorInfo weightsInfo({ 1, 3, 3, 1 }, armnn::DataType::Float32);
     const armnn::TensorInfo biasesInfo ({ 1 }, armnn::DataType::Float32);
 
     std::vector<float> weightsData = GenerateRandomData<float>(weightsInfo.GetNumElements());
     armnn::ConstTensor weights(weightsInfo, weightsData);
 
     std::vector<float> biasesData = GenerateRandomData<float>(biasesInfo.GetNumElements());
     armnn::ConstTensor biases(biasesInfo, biasesData);
 
     armnn::TransposeConvolution2dDescriptor descriptor;
     descriptor.m_PadLeft     = 1;
     descriptor.m_PadRight    = 1;
     descriptor.m_PadTop      = 1;
     descriptor.m_PadBottom   = 1;
     descriptor.m_StrideX     = 1;
     descriptor.m_StrideY     = 1;
     descriptor.m_BiasEnabled = true;
     descriptor.m_DataLayout  = armnn::DataLayout::NHWC;
 
     armnn::INetworkPtr network = armnn::INetwork::Create();
     armnn::IConnectableLayer* const inputLayer  = network->AddInputLayer(0);
     armnn::IConnectableLayer* const convLayer   =
             network->AddTransposeConvolution2dLayer(descriptor,
                                                     weights,
                                                     armnn::Optional<armnn::ConstTensor>(biases),
                                                     layerName.c_str());
     armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(convLayer->GetInputSlot(0));
     convLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     convLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     const std::vector<armnn::ConstTensor> constants {weights, biases};
     LayerVerifierBaseWithDescriptorAndConstants<armnn::TransposeConvolution2dDescriptor> verifier(
             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

◆ BOOST_AUTO_TEST_CASE() [61/61]

BOOST_AUTO_TEST_CASE ( SerializeDeserializeNonLinearNetwork )

Definition at line 2312 of file SerializerTests.cpp.

References armnn::Addition, BOOST_AUTO_TEST_SUITE_END(), CompareConstTensor(), IOutputSlot::Connect(), armnn::Constant, INetwork::Create(), DeserializeNetwork(), armnn::Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::info, armnn::Input, armnn::Output, SerializeNetwork(), and IOutputSlot::SetTensorInfo().

 {
     class ConstantLayerVerifier : public LayerVerifierBase
     {
     public:
         ConstantLayerVerifier(const std::string& layerName,
                               const std::vector<armnn::TensorInfo>& inputInfos,
                               const std::vector<armnn::TensorInfo>& outputInfos,
                               const armnn::ConstTensor& layerInput)
             : LayerVerifierBase(layerName, inputInfos, outputInfos)
             , m_LayerInput(layerInput) {}
 
         void ExecuteStrategy(const armnn::IConnectableLayer* layer,
                              const armnn::BaseDescriptor& descriptor,
                              const std::vector<armnn::ConstTensor>& constants,
                              const char* name,
                              const armnn::LayerBindingId id = 0) override
         {
             armnn::IgnoreUnused(descriptor, constants, id);
             switch (layer->GetType())
             {
                 case armnn::LayerType::Input: break;
                 case armnn::LayerType::Output: break;
                 case armnn::LayerType::Addition: break;
                 case armnn::LayerType::Constant:
                 {
                     VerifyNameAndConnections(layer, name);
                     CompareConstTensor(constants.at(0), m_LayerInput);
                     break;
                 }
                 default:
                 {
                     throw armnn::Exception("Unexpected layer type in test model");
                 }
             }
         }
 
     private:
         armnn::ConstTensor m_LayerInput;
     };
 
     const std::string layerName("constant");
     const armnn::TensorInfo info({ 2, 3 }, armnn::DataType::Float32);
 
     std::vector<float> constantData = GenerateRandomData<float>(info.GetNumElements());
     armnn::ConstTensor constTensor(info, constantData);
 
     armnn::INetworkPtr network(armnn::INetwork::Create());
     armnn::IConnectableLayer* input = network->AddInputLayer(0);
     armnn::IConnectableLayer* add = network->AddAdditionLayer();
     armnn::IConnectableLayer* constant = network->AddConstantLayer(constTensor, layerName.c_str());
     armnn::IConnectableLayer* output = network->AddOutputLayer(0);
 
     input->GetOutputSlot(0).Connect(add->GetInputSlot(0));
     constant->GetOutputSlot(0).Connect(add->GetInputSlot(1));
     add->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     input->GetOutputSlot(0).SetTensorInfo(info);
     constant->GetOutputSlot(0).SetTensorInfo(info);
     add->GetOutputSlot(0).SetTensorInfo(info);
 
     armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
     BOOST_CHECK(deserializedNetwork);
 
     ConstantLayerVerifier verifier(layerName, {}, {info}, constTensor);
     deserializedNetwork->ExecuteStrategy(verifier);
 }

Functions

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/61]

◆ BOOST_AUTO_TEST_CASE() [2/61]

◆ BOOST_AUTO_TEST_CASE() [3/61]

◆ BOOST_AUTO_TEST_CASE() [4/61]

◆ BOOST_AUTO_TEST_CASE() [5/61]

◆ BOOST_AUTO_TEST_CASE() [6/61]

◆ BOOST_AUTO_TEST_CASE() [7/61]

◆ BOOST_AUTO_TEST_CASE() [8/61]

◆ BOOST_AUTO_TEST_CASE() [9/61]

◆ BOOST_AUTO_TEST_CASE() [10/61]

◆ BOOST_AUTO_TEST_CASE() [11/61]

◆ BOOST_AUTO_TEST_CASE() [12/61]

◆ BOOST_AUTO_TEST_CASE() [13/61]

◆ BOOST_AUTO_TEST_CASE() [14/61]

◆ BOOST_AUTO_TEST_CASE() [15/61]

◆ BOOST_AUTO_TEST_CASE() [16/61]

◆ BOOST_AUTO_TEST_CASE() [17/61]

◆ BOOST_AUTO_TEST_CASE() [18/61]

◆ BOOST_AUTO_TEST_CASE() [19/61]

◆ BOOST_AUTO_TEST_CASE() [20/61]

◆ BOOST_AUTO_TEST_CASE() [21/61]

◆ BOOST_AUTO_TEST_CASE() [22/61]

◆ BOOST_AUTO_TEST_CASE() [23/61]

◆ BOOST_AUTO_TEST_CASE() [24/61]

◆ BOOST_AUTO_TEST_CASE() [25/61]

◆ BOOST_AUTO_TEST_CASE() [26/61]

◆ BOOST_AUTO_TEST_CASE() [27/61]

◆ BOOST_AUTO_TEST_CASE() [28/61]

◆ BOOST_AUTO_TEST_CASE() [29/61]

◆ BOOST_AUTO_TEST_CASE() [30/61]

◆ BOOST_AUTO_TEST_CASE() [31/61]

◆ BOOST_AUTO_TEST_CASE() [32/61]

◆ BOOST_AUTO_TEST_CASE() [33/61]

◆ BOOST_AUTO_TEST_CASE() [34/61]

◆ BOOST_AUTO_TEST_CASE() [35/61]

◆ BOOST_AUTO_TEST_CASE() [36/61]

◆ BOOST_AUTO_TEST_CASE() [37/61]

◆ BOOST_AUTO_TEST_CASE() [38/61]

◆ BOOST_AUTO_TEST_CASE() [39/61]

◆ BOOST_AUTO_TEST_CASE() [40/61]

◆ BOOST_AUTO_TEST_CASE() [41/61]

◆ BOOST_AUTO_TEST_CASE() [42/61]

◆ BOOST_AUTO_TEST_CASE() [43/61]

◆ BOOST_AUTO_TEST_CASE() [44/61]

◆ BOOST_AUTO_TEST_CASE() [45/61]

◆ BOOST_AUTO_TEST_CASE() [46/61]

◆ BOOST_AUTO_TEST_CASE() [47/61]

◆ BOOST_AUTO_TEST_CASE() [48/61]

◆ BOOST_AUTO_TEST_CASE() [49/61]

◆ BOOST_AUTO_TEST_CASE() [50/61]

◆ BOOST_AUTO_TEST_CASE() [51/61]

◆ BOOST_AUTO_TEST_CASE() [52/61]

◆ BOOST_AUTO_TEST_CASE() [53/61]

◆ BOOST_AUTO_TEST_CASE() [54/61]

◆ BOOST_AUTO_TEST_CASE() [55/61]

◆ BOOST_AUTO_TEST_CASE() [56/61]

◆ BOOST_AUTO_TEST_CASE() [57/61]

◆ BOOST_AUTO_TEST_CASE() [58/61]

◆ BOOST_AUTO_TEST_CASE() [59/61]

◆ BOOST_AUTO_TEST_CASE() [60/61]

◆ BOOST_AUTO_TEST_CASE() [61/61]