InferOutputTests.hpp File Reference

#include "TestUtils.hpp"
#include <Graph.hpp>
#include <layers/ArgMinMaxLayer.hpp>
#include <layers/BatchToSpaceNdLayer.hpp>
#include <layers/SpaceToDepthLayer.hpp>
#include <layers/PreluLayer.hpp>
#include <layers/StackLayer.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/test/unit_test.hpp>

Go to the source code of this file.

Functions
void	ArgMinMaxInferOutputShapeImpl (const armnn::ArgMinMaxDescriptor descriptor, const std::vector< armnn::TensorShape > &inputShapes, std::vector< armnn::TensorShape > &outputShapes)
void	ArgMinMaxInferOutputShape4dTest ()
void	ArgMinMaxInferOutputShape3dTest ()
void	ArgMinMaxInferOutputShape2dTest ()
void	ArgMinMaxInferOutputShape1dTest ()
void	BatchToSpaceInferOutputShapeTest ()
void	SpaceToDepthInferOutputShapeTest ()
void	PreluInferOutputShapeImpl (const std::vector< armnn::TensorShape > &inputShapes, std::vector< armnn::TensorShape > &outputShapes)
void	PreluInferOutputShapeSameDimsTest ()
void	PreluInferOutputShapeInputBiggerTest ()
void	PreluInferOutputShapeAlphaBiggerTest ()
void	PreluInferOutputShapeNoMatchTest ()
void	CreatePreluLayerHelper (armnn::Graph &graph, const armnn::TensorShape &inputShape, const armnn::TensorShape &alphaShape, const armnn::TensorShape &outputShape)
void	PreluValidateTensorShapesFromInputsMatchTest ()
void	PreluValidateTensorShapesFromInputsNoMatchTest ()
void	StackInferOutputShapeImpl (const armnn::StackDescriptor descriptor, const std::vector< armnn::TensorShape > &inputShapes, std::vector< armnn::TensorShape > &outputShapes)
void	StackInferOutputShapeFromInputsMatchTest ()
void	StackInferOutputShapeFromInputsNoMatchTest ()
void	CreateStackLayerHelper (armnn::Graph &graph, const armnn::StackDescriptor &descriptor, const std::vector< armnn::TensorShape > &inputShapes, const armnn::TensorShape &outputShape)
void	StackValidateTensorShapesFromInputsMatchTest ()
void	StackValidateTensorShapesFromInputsNoMatchTest ()
void	Convolution2dInferOutputShapeTest ()
void	TransposeConvolution2dInferOutputShapeTest ()
void	DepthwiseConvolution2dInferOutputShapeTest ()
void	QuantizedLstmInferOutputShapeImpl (const std::vector< armnn::TensorShape > &inputShapes, std::vector< armnn::TensorShape > &outputShapes)
void	QuantizedLstmInferOutputShapeTest ()

Function Documentation

ArgMinMaxInferOutputShape1dTest()

void ArgMinMaxInferOutputShape1dTest

(

)

Definition at line 87 of file InferOutputTests.hpp.

References ArgMinMaxInferOutputShapeImpl(), BOOST_CHECK(), and ArgMinMaxDescriptor::m_Axis.

{
    armnn::Graph graph;
    armnn::ArgMinMaxDescriptor descriptor;
    descriptor.m_Axis = 0;

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 5 }
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(ArgMinMaxInferOutputShapeImpl(descriptor, inputShapes, outputShapes));

    armnn::TensorShape expectedOutputShape( { 1 } );
    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShape);
}

ArgMinMaxInferOutputShape2dTest()

void ArgMinMaxInferOutputShape2dTest

(

)

Definition at line 68 of file InferOutputTests.hpp.

References ArgMinMaxInferOutputShapeImpl(), BOOST_CHECK(), and ArgMinMaxDescriptor::m_Axis.

{
    armnn::Graph graph;
    armnn::ArgMinMaxDescriptor descriptor;
    descriptor.m_Axis = 1;

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 3, 2 }
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(ArgMinMaxInferOutputShapeImpl(descriptor, inputShapes, outputShapes));

    armnn::TensorShape expectedOutputShape( { 3 } );
    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShape);
}

ArgMinMaxInferOutputShape3dTest()

void ArgMinMaxInferOutputShape3dTest

(

)

Definition at line 49 of file InferOutputTests.hpp.

References ArgMinMaxInferOutputShapeImpl(), BOOST_CHECK(), and ArgMinMaxDescriptor::m_Axis.

{
    armnn::Graph graph;
    armnn::ArgMinMaxDescriptor descriptor;
    descriptor.m_Axis = 0;

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 1, 3, 2 }
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(ArgMinMaxInferOutputShapeImpl(descriptor, inputShapes, outputShapes));

    armnn::TensorShape expectedOutputShape( { 3, 2 } );
    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShape);
}

ArgMinMaxInferOutputShape4dTest()

void ArgMinMaxInferOutputShape4dTest

(

)

Definition at line 30 of file InferOutputTests.hpp.

References ArgMinMaxInferOutputShapeImpl(), BOOST_CHECK(), and ArgMinMaxDescriptor::m_Axis.

{
    armnn::Graph graph;
    armnn::ArgMinMaxDescriptor descriptor;
    descriptor.m_Axis = 2;

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 1, 3, 2, 4 }
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(ArgMinMaxInferOutputShapeImpl(descriptor, inputShapes, outputShapes));

    armnn::TensorShape expectedOutputShape( { 1, 3, 4 } );
    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShape);
}

ArgMinMaxInferOutputShapeImpl()

void ArgMinMaxInferOutputShapeImpl	(	const armnn::ArgMinMaxDescriptor	descriptor,
		const std::vector< armnn::TensorShape > &	inputShapes,
		std::vector< armnn::TensorShape > &	outputShapes
	)

Definition at line 21 of file InferOutputTests.hpp.

References Graph::AddLayer(), and ArgMinMaxLayer::InferOutputShapes().

Referenced by ArgMinMaxInferOutputShape1dTest(), ArgMinMaxInferOutputShape2dTest(), ArgMinMaxInferOutputShape3dTest(), and ArgMinMaxInferOutputShape4dTest().

{
    armnn::Graph graph;
    auto argMinMaxLayer = graph.AddLayer<armnn::ArgMinMaxLayer>(descriptor, "argMinMax");
    outputShapes = argMinMaxLayer->InferOutputShapes(inputShapes);
}

BatchToSpaceInferOutputShapeTest()

void BatchToSpaceInferOutputShapeTest

(

)

Definition at line 106 of file InferOutputTests.hpp.

References Graph::AddLayer(), BOOST_CHECK(), BatchToSpaceNdLayer::InferOutputShapes(), BatchToSpaceNdDescriptor::m_BlockShape, BatchToSpaceNdDescriptor::m_Crops, BatchToSpaceNdDescriptor::m_DataLayout, and armnn::NHWC.

{
    armnn::Graph graph;

    armnn::BatchToSpaceNdDescriptor descriptor;
    descriptor.m_BlockShape = {2, 2};
    descriptor.m_Crops = {{0, 0}, {2, 0}};
    descriptor.m_DataLayout = armnn::DataLayout::NHWC;

    armnn::BatchToSpaceNdLayer* const batchToSpaceLayer =
        graph.AddLayer<armnn::BatchToSpaceNdLayer>(descriptor, "batchToSpace");

    std::vector<armnn::TensorShape> shapes;
    const std::vector<unsigned int> theDimSizes = {8, 1, 3, 1};
    armnn::TensorShape shape(4, theDimSizes.data());
    shapes.push_back(shape);

    const std::vector<unsigned int> expectedDimSizes = {2, 2, 4, 1};
    armnn::TensorShape expectedShape(4, expectedDimSizes.data());

    BOOST_CHECK(expectedShape == batchToSpaceLayer->InferOutputShapes(shapes).at(0));
}

Convolution2dInferOutputShapeTest()

void Convolution2dInferOutputShapeTest

(

)

Definition at line 436 of file InferOutputTests.hpp.

References Graph::AddLayer(), BOOST_CHECK(), Convolution2dLayer::InferOutputShapes(), Convolution2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_DilationX, Convolution2dDescriptor::m_DilationY, Convolution2dDescriptor::m_PadBottom, Convolution2dDescriptor::m_PadLeft, Convolution2dDescriptor::m_PadRight, Convolution2dDescriptor::m_PadTop, Convolution2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideY, and armnn::NCHW.

{
    armnn::Graph graph;

    armnn::Convolution2dDescriptor descriptor;
    descriptor.m_DilationX = 2;
    descriptor.m_DilationY = 2;
    descriptor.m_PadTop = 1;
    descriptor.m_PadBottom = 1;
    descriptor.m_PadLeft = 1;
    descriptor.m_PadRight = 1;
    descriptor.m_StrideX = 3;
    descriptor.m_StrideY = 3;
    descriptor.m_DataLayout = armnn::DataLayout::NCHW;

    armnn::Convolution2dLayer* const convolution2dLayer =
            graph.AddLayer<armnn::Convolution2dLayer>(descriptor, "convolution2d");

    std::vector<armnn::TensorShape> shapes;
    const std::vector<unsigned int> inputSize = {1, 2, 10, 10};
    armnn::TensorShape inputShape(4, inputSize.data());
    shapes.push_back(inputShape);

    const std::vector<unsigned int> filterSize = { 1, 2, 2, 2};
    armnn::TensorShape filterShape(4, filterSize.data());
    shapes.push_back(filterShape);

    const std::vector<unsigned int> expectedOutputSizes = {1, 1, 4, 4};
    armnn::TensorShape expectedOutputShape(4, expectedOutputSizes.data());

    BOOST_CHECK(expectedOutputShape == convolution2dLayer->InferOutputShapes(shapes).at(0));
}

CreatePreluLayerHelper()

void CreatePreluLayerHelper	(	armnn::Graph &	graph,
		const armnn::TensorShape &	inputShape,
		const armnn::TensorShape &	alphaShape,
		const armnn::TensorShape &	outputShape
	)

Definition at line 239 of file InferOutputTests.hpp.

References Graph::AddLayer(), Connect(), and armnn::Float32.

Referenced by PreluValidateTensorShapesFromInputsMatchTest(), and PreluValidateTensorShapesFromInputsNoMatchTest().

{
    // Creates the PReLU layer
    armnn::Layer* const preluLayer = graph.AddLayer<armnn::PreluLayer>("prelu");

    // Creates extra layers
    armnn::Layer* const input  = graph.AddLayer<armnn::InputLayer> (0, "input");
    armnn::Layer* const alpha  = graph.AddLayer<armnn::InputLayer> (1, "alpha");
    armnn::Layer* const output = graph.AddLayer<armnn::OutputLayer>(0, "output");

    // Connects up
    armnn::TensorInfo inputTensorInfo (inputShape,  armnn::DataType::Float32);
    armnn::TensorInfo alphaTensorInfo (alphaShape,  armnn::DataType::Float32);
    armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
    Connect(input, preluLayer,  inputTensorInfo,  0, 0);
    Connect(alpha, preluLayer,  alphaTensorInfo,  0, 1);
    Connect(preluLayer, output, outputTensorInfo, 0, 0);
}

CreateStackLayerHelper()

void CreateStackLayerHelper	(	armnn::Graph &	graph,
		const armnn::StackDescriptor &	descriptor,
		const std::vector< armnn::TensorShape > &	inputShapes,
		const armnn::TensorShape &	outputShape
	)

Definition at line 353 of file InferOutputTests.hpp.

References Graph::AddLayer(), Connect(), and armnn::Float32.

Referenced by StackValidateTensorShapesFromInputsMatchTest(), and StackValidateTensorShapesFromInputsNoMatchTest().

{
    // Creates the Stack layer
    armnn::Layer* const stackLayer = graph.AddLayer<armnn::StackLayer>(descriptor, "stack");

    // Creates extra layers
    std::vector<armnn::Layer*> inputs;
    for (unsigned int i=0; i<inputShapes.size(); ++i)
    {
        inputs.push_back(graph.AddLayer<armnn::InputLayer>(static_cast<int>(i), "input"));
    }
    armnn::Layer* const output = graph.AddLayer<armnn::OutputLayer>(0, "output");

    // Connects up
    std::vector<armnn::TensorInfo> inputTensorInfos;
    for (unsigned int i=0; i<inputs.size(); ++i)
    {
        inputTensorInfos.push_back(armnn::TensorInfo(inputShapes[i], armnn::DataType::Float32));
    }
    armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);

    for (unsigned int i=0; i<inputs.size(); ++i)
    {
        Connect(inputs[i], stackLayer, inputTensorInfos[i], 0, i);
    }
    Connect(stackLayer, output, outputTensorInfo, 0, 0);
}

DepthwiseConvolution2dInferOutputShapeTest()

void DepthwiseConvolution2dInferOutputShapeTest

(

)

Definition at line 500 of file InferOutputTests.hpp.

References Graph::AddLayer(), BOOST_CHECK(), DepthwiseConvolution2dLayer::InferOutputShapes(), DepthwiseConvolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_DilationX, DepthwiseConvolution2dDescriptor::m_DilationY, DepthwiseConvolution2dDescriptor::m_PadBottom, DepthwiseConvolution2dDescriptor::m_PadLeft, DepthwiseConvolution2dDescriptor::m_PadRight, DepthwiseConvolution2dDescriptor::m_PadTop, DepthwiseConvolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideY, and armnn::NCHW.

{
    armnn::Graph graph;

    armnn::DepthwiseConvolution2dDescriptor descriptor;
    descriptor.m_DilationX = 3;
    descriptor.m_DilationY = 3;
    descriptor.m_PadTop = 1;
    descriptor.m_PadBottom = 2;
    descriptor.m_PadLeft = 1;
    descriptor.m_PadRight = 2;
    descriptor.m_StrideX = 2;
    descriptor.m_StrideY = 2;
    descriptor.m_DataLayout = armnn::DataLayout::NCHW;

    armnn::DepthwiseConvolution2dLayer* const depthwiseConvolution2dLayer =
            graph.AddLayer<armnn::DepthwiseConvolution2dLayer>(descriptor, "DepthwiseConvolution2d");

    std::vector<armnn::TensorShape> shapes;
    const std::vector<unsigned int> inputSize = {1, 2, 10, 10};
    armnn::TensorShape inputShape(4, inputSize.data());
    shapes.push_back(inputShape);

    const std::vector<unsigned int> filterSize = { 1, 2, 3, 3};
    armnn::TensorShape filterShape(4, filterSize.data());
    shapes.push_back(filterShape);

    const std::vector<unsigned int> expectedOutputSizes = {1, 2, 4, 4};
    armnn::TensorShape expectedOutputShape(4, expectedOutputSizes.data());

    BOOST_CHECK(expectedOutputShape == depthwiseConvolution2dLayer->InferOutputShapes(shapes).at(0));
}

PreluInferOutputShapeAlphaBiggerTest()

void PreluInferOutputShapeAlphaBiggerTest

(

)

Definition at line 199 of file InferOutputTests.hpp.

References BOOST_CHECK(), and PreluInferOutputShapeImpl().

{
    const std::vector<armnn::TensorShape> inputShapes
    {
        { 4, 1, 2 },   // Input shape
        { 5, 4, 3, 1 } // Alpha shape
    };

    const std::vector<armnn::TensorShape> expectedOutputShapes
    {
        { 5, 4, 3, 2 } // Output shape
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(PreluInferOutputShapeImpl(inputShapes, outputShapes));

    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShapes[0]);
}

PreluInferOutputShapeImpl()

void PreluInferOutputShapeImpl	(	const std::vector< armnn::TensorShape > &	inputShapes,
		std::vector< armnn::TensorShape > &	outputShapes
	)

Definition at line 151 of file InferOutputTests.hpp.

References Graph::AddLayer(), and PreluLayer::InferOutputShapes().

Referenced by PreluInferOutputShapeAlphaBiggerTest(), PreluInferOutputShapeInputBiggerTest(), PreluInferOutputShapeNoMatchTest(), and PreluInferOutputShapeSameDimsTest().

{
    armnn::Graph graph;
    armnn::PreluLayer* const preluLayer = graph.AddLayer<armnn::PreluLayer>("prelu");
    outputShapes = preluLayer->InferOutputShapes(inputShapes);
}

PreluInferOutputShapeInputBiggerTest()

void PreluInferOutputShapeInputBiggerTest

(

)

Definition at line 179 of file InferOutputTests.hpp.

References BOOST_CHECK(), and PreluInferOutputShapeImpl().

{
    const std::vector<armnn::TensorShape> inputShapes
    {
        { 4, 1, 4, 8 }, // Input shape
        { 5, 4, 1 }     // Alpha shape
    };

    const std::vector<armnn::TensorShape> expectedOutputShapes
    {
        { 4, 5, 4, 8 } // Output shape
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(PreluInferOutputShapeImpl(inputShapes, outputShapes));

    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShapes[0]);
}

PreluInferOutputShapeNoMatchTest()

void PreluInferOutputShapeNoMatchTest

(

)

Definition at line 219 of file InferOutputTests.hpp.

References BOOST_CHECK(), and PreluInferOutputShapeImpl().

{
    const std::vector<armnn::TensorShape> inputShapes
    {
        { 4, 1, 2 },   // Input shape
        { 5, 4, 3, 1 } // Alpha shape
    };

    const std::vector<armnn::TensorShape> expectedOutputShapes
    {
        { 5, 7, 3, 2 } // Output shape
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(PreluInferOutputShapeImpl(inputShapes, outputShapes));

    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] != expectedOutputShapes[0]);
}

PreluInferOutputShapeSameDimsTest()

void PreluInferOutputShapeSameDimsTest

(

)

Definition at line 159 of file InferOutputTests.hpp.

References BOOST_CHECK(), and PreluInferOutputShapeImpl().

{
    const std::vector<armnn::TensorShape> inputShapes
    {
        { 5, 1, 1, 7 }, // Input shape
        { 5, 4, 3, 1 }  // Alpha shape
    };

    const std::vector<armnn::TensorShape> expectedOutputShapes
    {
        { 5, 4, 3, 7 }  // Output shape
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(PreluInferOutputShapeImpl(inputShapes, outputShapes));

    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShapes[0]);
}

PreluValidateTensorShapesFromInputsMatchTest()

void PreluValidateTensorShapesFromInputsMatchTest

(

)

Definition at line 261 of file InferOutputTests.hpp.

References CreatePreluLayerHelper(), and Graph::InferTensorInfos().

{
    armnn::Graph graph;

    // Creates the PReLU layer
    CreatePreluLayerHelper(graph, { 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 });

    // Graph::InferTensorInfos calls Layer::ValidateTensorShapesFromInputs
    BOOST_CHECK_NO_THROW(graph.InferTensorInfos());
}

PreluValidateTensorShapesFromInputsNoMatchTest()

void PreluValidateTensorShapesFromInputsNoMatchTest

(

)

Definition at line 272 of file InferOutputTests.hpp.

References CreatePreluLayerHelper(), and Graph::InferTensorInfos().

{
    armnn::Graph graph;

    // Creates the PReLU layer
    CreatePreluLayerHelper(graph, { 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 7, 3, 2 });

    // Graph::InferTensorInfos calls Layer::ValidateTensorShapesFromInputs
    BOOST_CHECK_THROW(graph.InferTensorInfos(), armnn::LayerValidationException);
}

QuantizedLstmInferOutputShapeImpl()

void QuantizedLstmInferOutputShapeImpl	(	const std::vector< armnn::TensorShape > &	inputShapes,
		std::vector< armnn::TensorShape > &	outputShapes
	)

Definition at line 534 of file InferOutputTests.hpp.

References Graph::AddLayer(), and QuantizedLstmLayer::InferOutputShapes().

Referenced by QuantizedLstmInferOutputShapeTest().

{
    armnn::Graph graph;
    armnn::QuantizedLstmLayer* const quantizedLstmLayer = graph.AddLayer<armnn::QuantizedLstmLayer>("quantizedLstm");
    outputShapes = quantizedLstmLayer->InferOutputShapes(inputShapes);
}

QuantizedLstmInferOutputShapeTest()

void QuantizedLstmInferOutputShapeTest

(

)

Definition at line 542 of file InferOutputTests.hpp.

References BOOST_CHECK(), and QuantizedLstmInferOutputShapeImpl().

{
    // Input shapes
    const std::vector<unsigned int> inputShape{ 2, 5 };
    const std::vector<unsigned int> previousCellStateInShape{ 2, 10 };
    const std::vector<unsigned int> previousOutputInShape{ 2, 10 };
    armnn::TensorShape inputTensorShape(2, inputShape.data());
    armnn::TensorShape previousCellStateInTensorShape(2, previousCellStateInShape.data());
    armnn::TensorShape previousOutputInTensorShape(2, previousOutputInShape.data());

    std::vector<armnn::TensorShape> inShapes
    {
        inputTensorShape,
        previousCellStateInTensorShape,
        previousOutputInTensorShape
    };

    // Output shapes
    const std::vector<unsigned int> cellStateOutShape{ 2, 10 };
    const std::vector<unsigned int> outputShape{ 2, 10 };
    armnn::TensorShape cellStateOutTensorShape(2, cellStateOutShape.data());
    armnn::TensorShape outputTensorShape(2, outputShape.data());

    std::vector<armnn::TensorShape> expectedOutShapes
    {
        cellStateOutTensorShape,
        outputTensorShape
    };

    std::vector<armnn::TensorShape> actualOutShapes;
    BOOST_CHECK_NO_THROW(QuantizedLstmInferOutputShapeImpl(inShapes, actualOutShapes));

    BOOST_CHECK(actualOutShapes.size() == 2);
    BOOST_CHECK(expectedOutShapes[0] == actualOutShapes[0]);
    BOOST_CHECK(expectedOutShapes[1] == actualOutShapes[1]);
}

SpaceToDepthInferOutputShapeTest()

void SpaceToDepthInferOutputShapeTest

(

)

Definition at line 129 of file InferOutputTests.hpp.

References Graph::AddLayer(), BOOST_CHECK(), SpaceToDepthLayer::InferOutputShapes(), SpaceToDepthDescriptor::m_BlockSize, SpaceToDepthDescriptor::m_DataLayout, and armnn::NHWC.

{
    armnn::Graph graph;

    armnn::SpaceToDepthDescriptor descriptor;
    descriptor.m_BlockSize  = 2;
    descriptor.m_DataLayout = armnn::DataLayout::NHWC;

    armnn::SpaceToDepthLayer* const spaceToDepthLayer =
        graph.AddLayer<armnn::SpaceToDepthLayer>(descriptor, "spaceToDepth");

    std::vector<armnn::TensorShape> shapes;
    const std::vector<unsigned int> dimSizes{ 1, 16, 8, 3 };
    armnn::TensorShape shape(4, dimSizes.data());
    shapes.push_back(shape);

    const std::vector<unsigned int> expectedDimSizes{ 1, 8, 4, 12 };
    armnn::TensorShape expectedShape(4, expectedDimSizes.data());

    BOOST_CHECK(expectedShape == spaceToDepthLayer->InferOutputShapes(shapes).at(0));
}

StackInferOutputShapeFromInputsMatchTest()

void StackInferOutputShapeFromInputsMatchTest

(

)

Definition at line 292 of file InferOutputTests.hpp.

References BOOST_CHECK(), StackDescriptor::m_Axis, StackDescriptor::m_InputShape, StackDescriptor::m_NumInputs, and StackInferOutputShapeImpl().

{
    armnn::Graph graph;

    armnn::StackDescriptor descriptor;
    descriptor.m_Axis = 1;
    descriptor.m_NumInputs = 3;
    descriptor.m_InputShape = armnn::TensorShape
    (
        { 4, 2 }  // Defined input shape
    );

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 4, 2 }, // Actual input shapes
        { 4, 2 },
        { 4, 2 }
    };

    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(StackInferOutputShapeImpl(descriptor, inputShapes, outputShapes));

    armnn::TensorShape expectedOutputShape
    (
        { 4, 3, 2 }
    );
    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShape);
}

StackInferOutputShapeFromInputsNoMatchTest()

void StackInferOutputShapeFromInputsNoMatchTest

(

)

Definition at line 322 of file InferOutputTests.hpp.

References BOOST_CHECK(), StackDescriptor::m_Axis, StackDescriptor::m_InputShape, StackDescriptor::m_NumInputs, and StackInferOutputShapeImpl().

{
    armnn::Graph graph;

    armnn::StackDescriptor descriptor;
    descriptor.m_Axis = 1;
    descriptor.m_NumInputs = 3;
    descriptor.m_InputShape = armnn::TensorShape
    (
        { 4, 2 }  // Defined input shape
    );

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 4, 2 }, // Actual input shapes
        { 4, 5 }, // Incorrectly shaped input tensor
        { 4, 2 }
    };

    // Output shape is inferred from the descriptor, so should still be correct despite mismatching input shapes
    std::vector<armnn::TensorShape> outputShapes;
    BOOST_CHECK_NO_THROW(StackInferOutputShapeImpl(descriptor, inputShapes, outputShapes));

    armnn::TensorShape expectedOutputShape
    (
        { 4, 3, 2 }
    );
    BOOST_CHECK(outputShapes.size() == 1);
    BOOST_CHECK(outputShapes[0] == expectedOutputShape);
}

StackInferOutputShapeImpl()

void StackInferOutputShapeImpl	(	const armnn::StackDescriptor	descriptor,
		const std::vector< armnn::TensorShape > &	inputShapes,
		std::vector< armnn::TensorShape > &	outputShapes
	)

Definition at line 283 of file InferOutputTests.hpp.

References Graph::AddLayer(), and StackLayer::InferOutputShapes().

Referenced by StackInferOutputShapeFromInputsMatchTest(), and StackInferOutputShapeFromInputsNoMatchTest().

{
    armnn::Graph graph;
    armnn::StackLayer* const stackLayer = graph.AddLayer<armnn::StackLayer>(descriptor, "stack");
    outputShapes = stackLayer->InferOutputShapes(inputShapes);
}

StackValidateTensorShapesFromInputsMatchTest()

void StackValidateTensorShapesFromInputsMatchTest

(

)

Definition at line 384 of file InferOutputTests.hpp.

References CreateStackLayerHelper(), Graph::InferTensorInfos(), StackDescriptor::m_Axis, StackDescriptor::m_InputShape, and StackDescriptor::m_NumInputs.

{
    armnn::Graph graph;

    armnn::StackDescriptor descriptor;
    descriptor.m_Axis = 0;
    descriptor.m_NumInputs = 3;
    descriptor.m_InputShape = armnn::TensorShape
    (
        { 2, 5 }  // Defined input shape
    );

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 2, 5 }, // Actual input shapes
        { 2, 5 },
        { 2, 5 }
    };

    // Creates the Stack layer
    CreateStackLayerHelper(graph, descriptor, inputShapes, { 3, 2, 5 });

    // Graph::InferTensorInfos calls Layer::ValidateTensorShapesFromInputs
    BOOST_CHECK_NO_THROW(graph.InferTensorInfos());
}

StackValidateTensorShapesFromInputsNoMatchTest()

void StackValidateTensorShapesFromInputsNoMatchTest

(

)

Definition at line 410 of file InferOutputTests.hpp.

References CreateStackLayerHelper(), Graph::InferTensorInfos(), StackDescriptor::m_Axis, StackDescriptor::m_InputShape, and StackDescriptor::m_NumInputs.

{
    armnn::Graph graph;

    armnn::StackDescriptor descriptor;
    descriptor.m_Axis = 0;
    descriptor.m_NumInputs = 3;
    descriptor.m_InputShape = armnn::TensorShape
    (
        { 2, 5 }  // Defined input shape
    );

    const std::vector<armnn::TensorShape> inputShapes
    {
        { 2, 5 }, // Actual input shapes
        { 2, 2 }, // Incorrectly shaped input tensor
        { 2, 5 }
    };

    // Creates the Stack layer
    CreateStackLayerHelper(graph, descriptor, inputShapes, { 3, 2, 5 });

    // Graph::InferTensorInfos calls Layer::ValidateTensorShapesFromInputs
    BOOST_CHECK_THROW(graph.InferTensorInfos(), armnn::LayerValidationException);
}

TransposeConvolution2dInferOutputShapeTest()

void TransposeConvolution2dInferOutputShapeTest

(

)

Definition at line 469 of file InferOutputTests.hpp.

References Graph::AddLayer(), BOOST_CHECK(), TransposeConvolution2dLayer::InferOutputShapes(), TransposeConvolution2dDescriptor::m_DataLayout, TransposeConvolution2dDescriptor::m_PadBottom, TransposeConvolution2dDescriptor::m_PadLeft, TransposeConvolution2dDescriptor::m_PadRight, TransposeConvolution2dDescriptor::m_PadTop, TransposeConvolution2dDescriptor::m_StrideX, TransposeConvolution2dDescriptor::m_StrideY, and armnn::NCHW.

{
    armnn::Graph graph;

    armnn::TransposeConvolution2dDescriptor descriptor;
    descriptor.m_PadTop = 0;
    descriptor.m_PadBottom = 1;
    descriptor.m_PadLeft = 0;
    descriptor.m_PadRight = 1;
    descriptor.m_StrideX = 2;
    descriptor.m_StrideY = 2;
    descriptor.m_DataLayout = armnn::DataLayout::NCHW;

    armnn::TransposeConvolution2dLayer* const transposeConvolution2dLayer =
            graph.AddLayer<armnn::TransposeConvolution2dLayer>(descriptor, "TransposeConvolution2d");

    std::vector<armnn::TensorShape> shapes;
    const std::vector<unsigned int> inputSize = {1, 2, 3, 3};
    armnn::TensorShape inputShape(4, inputSize.data());
    shapes.push_back(inputShape);

    const std::vector<unsigned int> filterSize = { 1, 2, 3, 3};
    armnn::TensorShape filterShape(4, filterSize.data());
    shapes.push_back(filterShape);

    const std::vector<unsigned int> expectedOutputSizes = {1, 1, 6, 6};
    armnn::TensorShape expectedOutputShape(4, expectedOutputSizes.data());

    BOOST_CHECK(expectedOutputShape == transposeConvolution2dLayer->InferOutputShapes(shapes).at(0));
}