Conv2D.cpp File Reference

#include <boost/test/unit_test.hpp>
#include "ParserFlatbuffersFixture.hpp"
#include "../TfLiteParser.hpp"
#include <sstream>

Go to the source code of this file.

Functions
	BOOST_FIXTURE_TEST_CASE (ParseSimpleConv2D, SimpleConv2DFixture)
	BOOST_FIXTURE_TEST_CASE (ParseConv2DWithBias, SimpleConv2DWithBiasesFixture)
	BOOST_FIXTURE_TEST_CASE (ParseDynamicConv2DWithBias, DynamicConv2DWithBiasesFixture)
	BOOST_FIXTURE_TEST_CASE (ParseConv2D_112x112_out, Conv2DShapeTestFixture)
	BOOST_FIXTURE_TEST_CASE (ParseConv2DAndReluWithBias, ReluConv2DWithBiasesFixture)
	BOOST_FIXTURE_TEST_CASE (ParseConv2DAndRelu6WithBias, Relu6Conv2DWithBiasesFixture)

Function Documentation

BOOST_FIXTURE_TEST_CASE() [1/6]

BOOST_FIXTURE_TEST_CASE	(	ParseSimpleConv2D	,
		SimpleConv2DFixture
	)

Definition at line 90 of file Conv2D.cpp.

{
    RunTest<4, armnn::DataType::QAsymmU8>(
        0,
        {
            1, 2, 3,
            4, 5, 6,
            7, 8, 9,
        },
        // because of the output scaling we need to take half of the values
        {
            (1*2 + 2*1 + 3*0 +
             4*6 + 5*2 + 6*1 +
             7*4 + 8*1 + 9*2) /2
        });
}

BOOST_FIXTURE_TEST_CASE() [2/6]

BOOST_FIXTURE_TEST_CASE	(	ParseConv2DWithBias	,
		SimpleConv2DWithBiasesFixture
	)

Definition at line 220 of file Conv2D.cpp.

{
    RunTest<4, armnn::DataType::QAsymmU8>(
        0,
        {
            1, 2,
            3, 4,
        },
        // because of the output scaling we need to take half of the values
        {
            (1*2 + 2*1 + 3*0 + 4*6 + 10)/2,
            (2*2 + 0*1 + 4*0 + 0*6 + 10)/2,
            (3*2 + 4*1 + 0*0 + 0*6 + 10)/2,
            (4*2 + 0*1 + 0*0 + 0*6 + 10)/2
        });
}

BOOST_FIXTURE_TEST_CASE() [3/6]

BOOST_FIXTURE_TEST_CASE	(	ParseDynamicConv2DWithBias	,
		DynamicConv2DWithBiasesFixture
	)

Definition at line 250 of file Conv2D.cpp.

References armnn::QAsymmU8.

{
    RunTest<4,
        armnn::DataType::QAsymmU8,
        armnn::DataType::QAsymmU8>(0,
                                   { { "inputTensor", { 1, 2, 3, 4, } } },
                                   { { "outputTensor", {   (1*2 + 2*1 + 3*0 + 4*6 + 10)/2,
                                                           (2*2 + 0*1 + 4*0 + 0*6 + 10)/2,
                                                           (3*2 + 4*1 + 0*0 + 0*6 + 10)/2,
                                                           (4*2 + 0*1 + 0*0 + 0*6 + 10)/2} } },
                                   true);
}

BOOST_FIXTURE_TEST_CASE() [4/6]

BOOST_FIXTURE_TEST_CASE	(	ParseConv2D_112x112_out	,
		Conv2DShapeTestFixture
	)

Definition at line 291 of file Conv2D.cpp.

{
}

BOOST_FIXTURE_TEST_CASE() [5/6]

BOOST_FIXTURE_TEST_CASE	(	ParseConv2DAndReluWithBias	,
		ReluConv2DWithBiasesFixture
	)

Definition at line 313 of file Conv2D.cpp.

{
    uint8_t bias = 16;
    uint8_t outZero = 20;
    uint8_t fz = 4; // filter zero point

    RunTest<4, armnn::DataType::QAsymmU8>(
        0,
        {
            1, 2,
            4, 8,
        },
        // factors to consider:
        // - the filter zero point is non zero, hence the (x-fz)
        // - the output scale is 2 hence the /2
        // - output zero point is non zero, hence the +outZero
        // - RELU cuts negative values and then we add the output zero point
        {
            std::max(outZero, static_cast<uint8_t>((1*(2-fz) + 2*(1-fz) + 4*(0-fz) + 8*(6-fz) + bias)/2 + outZero)),
            std::max(outZero, static_cast<uint8_t>((2*(2-fz) + 0*(1-fz) + 8*(0-fz) + 0*(6-fz) + bias)/2 + outZero)),
            std::max(outZero, static_cast<uint8_t>((4*(2-fz) + 8*(1-fz) + 0*(0-fz) + 0*(6-fz) + bias)/2 + outZero)),
            std::max(outZero, static_cast<uint8_t>((8*(2-fz) + 0*(1-fz) + 0*(0-fz) + 0*(6-fz) + bias)/2 + outZero))
        });
}

BOOST_FIXTURE_TEST_CASE() [6/6]

BOOST_FIXTURE_TEST_CASE	(	ParseConv2DAndRelu6WithBias	,
		Relu6Conv2DWithBiasesFixture
	)

Definition at line 356 of file Conv2D.cpp.

References BOOST_AUTO_TEST_SUITE_END().

{
    uint8_t relu6Min = 6 / 2; // divide by output scale

    RunTest<4, armnn::DataType::QAsymmU8>(
        0,
        {
            1, 2,
            4, 1,
        },
        // factors to consider:
        // - the output scale is 2 hence the /2
        // - RELU6 cuts output values at +6
        {
            std::min(relu6Min, static_cast<uint8_t>((1*2 + 2*1 + 4*0 + 1*6)/2)),
            std::min(relu6Min, static_cast<uint8_t>((2*2 + 0*1 + 1*0 + 0*6)/2)),
            std::min(relu6Min, static_cast<uint8_t>((4*2 + 1*1 + 0*0 + 0*6)/2)),
            std::min(relu6Min, static_cast<uint8_t>((1*2 + 0*1 + 0*0 + 0*6)/2))
        });
}