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)
	BOOST_FIXTURE_TEST_CASE (ParsePerChannelConv2D, PerChannelConv2DFixture)

Function Documentation

BOOST_FIXTURE_TEST_CASE() [1/7]

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/7]

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/7]

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/7]

BOOST_FIXTURE_TEST_CASE	(	ParseConv2D_112x112_out	,
		Conv2DShapeTestFixture
	)

Definition at line 291 of file Conv2D.cpp.

{
}

BOOST_FIXTURE_TEST_CASE() [5/7]

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/7]

BOOST_FIXTURE_TEST_CASE	(	ParseConv2DAndRelu6WithBias	,
		Relu6Conv2DWithBiasesFixture
	)

Definition at line 356 of file Conv2D.cpp.

{
    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))
        });
}

BOOST_FIXTURE_TEST_CASE() [7/7]

BOOST_FIXTURE_TEST_CASE	(	ParsePerChannelConv2D	,
		PerChannelConv2DFixture
	)

Definition at line 645 of file Conv2D.cpp.

References BOOST_AUTO_TEST_SUITE_END().

{
    RunTest<4, armnn::DataType::QAsymmS8>(
        0,
        {
            -11, 40,-26, 11,-28,  8,  0, -8,
            -10, 34, 47,  0,-33,-14, 28, 35,
              6,-28,-26,  8, 13, 33,-31,-41,
             31,-20,-31,-16,  8,-18,-44,  0
        },
        {
            -21,-17,-23,-14, -1,-14,  1,  9,
              1,-12,-22,-23,  2, -1, -3, 12,
              7,  6,  8,-13,-21, -6,-31,  0,
              9, -6, 24,  0,-22, -4, -7,-22,
             -7, -9,  9, 11,-11,-16,  9,-27,
             -1,  0,-26,  0,  9,-12, -8,-18,
            -11, -3,-15,  7, 16, -2, -8, -7,
            -14,-15,-14,  3,  9,-12, -6,-11
        });
}