TensorHelpers.hpp File Reference

#include <armnn/Tensor.hpp>
#include <QuantizeHelper.hpp>
#include <boost/assert.hpp>
#include <boost/multi_array.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/test/tools/floating_point_comparison.hpp>
#include <boost/test/unit_test.hpp>
#include <array>
#include <cmath>
#include <vector>

Go to the source code of this file.

Classes
struct	SelectiveComparer< T, isQuantized >
struct	SelectiveComparer< T, false >

Functions
template<typename T >
bool	SelectiveCompare (T a, T b)
template<typename T >
bool	SelectiveCompareBoolean (T a, T b)
template<typename T , std::size_t n>
boost::test_tools::predicate_result	CompareTensors (const boost::multi_array< T, n > &a, const boost::multi_array< T, n > &b, bool compareBoolean=false)
template<typename T , std::size_t n>
boost::multi_array< T, n >	MakeTensor (const armnn::TensorInfo &tensorInfo)
template<typename T , std::size_t n>
boost::multi_array< T, n >	MakeTensor (const armnn::TensorInfo &tensorInfo, const std::vector< T > &flat)
template<typename T , std::size_t n>
boost::multi_array< T, n >	MakeRandomTensor (const armnn::TensorInfo &tensorInfo, unsigned int seed, float min=-10.0f, float max=10.0f)

Variables
constexpr float	g_FloatCloseToZeroTolerance = 1.0e-6f

Function Documentation

CompareTensors()

boost::test_tools::predicate_result CompareTensors	(	const boost::multi_array< T, n > &	a,
		const boost::multi_array< T, n > &	b,
		bool	compareBoolean = false
	)

Definition at line 75 of file TensorHelpers.hpp.

References SelectiveCompare(), and SelectiveCompareBoolean().

Referenced by BOOST_AUTO_TEST_CASE(), CompareTestResultIfSupported(), DetectionPostProcessImpl(), ParserPrototxtFixture< armnnOnnxParser::IOnnxParser >::RunTest(), ParserFlatbuffersSerializeFixture::RunTest(), and ParserFlatbuffersFixture::RunTest().

{
    // Checks they are same shape.
    for (unsigned int i=0; i<n; i++)
    {
        if (a.shape()[i] != b.shape()[i])
        {
            boost::test_tools::predicate_result res(false);
            res.message() << "Different shapes ["
                        << a.shape()[i]
                        << "!="
                        << b.shape()[i]
                        << "]";
            return res;
        }
    }

    // Now compares element-wise.

    // Fun iteration over n dimensions.
    std::array<unsigned int, n> indices;
    for (unsigned int i = 0; i < n; i++)
    {
        indices[i] = 0;
    }

    std::stringstream errorString;
    int numFailedElements = 0;
    constexpr int maxReportedDifferences = 3;

    while (true)
    {
        bool comparison;
        // As true for uint8_t is non-zero (1-255) we must have a dedicated compare for Booleans.
        if(compareBoolean)
        {
            comparison = SelectiveCompareBoolean(a(indices), b(indices));
        }
        else
        {
            comparison = SelectiveCompare(a(indices), b(indices));
        }

        if (!comparison)
        {
            ++numFailedElements;

            if (numFailedElements <= maxReportedDifferences)
            {
                if (numFailedElements >= 2)
                {
                    errorString << ", ";
                }
                errorString << "[";
                for (unsigned int i = 0; i < n; ++i)
                {
                    errorString << indices[i];
                    if (i != n - 1)
                    {
                        errorString << ",";
                    }
                }
                errorString << "]";

                errorString << " (" << +a(indices) << " != " << +b(indices) << ")";
            }
        }

        ++indices[n - 1];
        for (unsigned int i=n-1; i>0; i--)
        {
            if (indices[i] == a.shape()[i])
            {
                indices[i] = 0;
                ++indices[i - 1];
            }
        }

        if (indices[0] == a.shape()[0])
        {
            break;
        }
    }

    boost::test_tools::predicate_result comparisonResult(true);
    if (numFailedElements > 0)
    {
        comparisonResult = false;
        comparisonResult.message() << numFailedElements << " different values at: ";
        if (numFailedElements > maxReportedDifferences)
        {
            errorString << ", ... (and " << (numFailedElements - maxReportedDifferences) << " other differences)";
        }
        comparisonResult.message() << errorString.str();
    }

    return comparisonResult;
}

MakeRandomTensor()

boost::multi_array<T, n> MakeRandomTensor	(	const armnn::TensorInfo &	tensorInfo,
		unsigned int	seed,
		float	min = -10.0f,
		float	max = 10.0f
	)

Definition at line 223 of file TensorHelpers.hpp.

References TensorInfo::GetNumElements(), TensorInfo::GetQuantizationOffset(), and TensorInfo::GetQuantizationScale().

{
    boost::random::mt19937                          gen(seed);
    boost::random::uniform_real_distribution<float> dist(min, max);

    std::vector<float> init(tensorInfo.GetNumElements());
    for (unsigned int i = 0; i < init.size(); i++)
    {
        init[i] = dist(gen);
    }

    const float   qScale  = tensorInfo.GetQuantizationScale();
    const int32_t qOffset = tensorInfo.GetQuantizationOffset();

    return MakeTensor<T, n>(tensorInfo, armnnUtils::QuantizedVector<T>(init, qScale, qOffset));
}

MakeTensor() [1/2]

boost::multi_array<T, n> MakeTensor

(

const armnn::TensorInfo &

tensorInfo

)

Definition at line 179 of file TensorHelpers.hpp.

References TensorInfo::GetShape().

{
    std::array<unsigned int, n> shape;

    for (unsigned int i = 0; i < n; i++)
    {
        shape[i] = tensorInfo.GetShape()[i];
    }

    return boost::multi_array<T, n>(shape);
}

MakeTensor() [2/2]

boost::multi_array<T, n> MakeTensor	(	const armnn::TensorInfo &	tensorInfo,
		const std::vector< T > &	flat
	)

Definition at line 193 of file TensorHelpers.hpp.

References TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), and TensorInfo::GetShape().

{
    BOOST_ASSERT_MSG(flat.size() == tensorInfo.GetNumElements(), "Wrong number of components supplied to tensor");

    std::array<unsigned int, n> shape;

    // NOTE: tensorInfo.GetNumDimensions() might be different from n
    const unsigned int returnDimensions = static_cast<unsigned int>(n);
    const unsigned int actualDimensions = tensorInfo.GetNumDimensions();

    const unsigned int paddedDimensions =
        returnDimensions > actualDimensions ? returnDimensions - actualDimensions : 0u;

    for (unsigned int i = 0u; i < returnDimensions; i++)
    {
        if (i < paddedDimensions)
        {
            shape[i] = 1u;
        }
        else
        {
            shape[i] = tensorInfo.GetShape()[i - paddedDimensions];
        }
    }

    boost::const_multi_array_ref<T, n> arrayRef(&flat[0], shape);
    return boost::multi_array<T, n>(arrayRef);
}

SelectiveCompare()

bool SelectiveCompare	(	T	a,
		T	b
	)

Definition at line 63 of file TensorHelpers.hpp.

References SelectiveComparer< T, isQuantized >::Compare().

Referenced by CompareTensors().

{
    return SelectiveComparer<T, armnn::IsQuantizedType<T>()>::Compare(a, b);
};

SelectiveCompareBoolean()

bool SelectiveCompareBoolean	(	T	a,
		T	b
	)

Definition at line 69 of file TensorHelpers.hpp.

Referenced by CompareTensors().

{
    return (((a == 0) && (b == 0)) || ((a != 0) && (b != 0)));
};

Variable Documentation

g_FloatCloseToZeroTolerance

constexpr float g_FloatCloseToZeroTolerance = 1.0e-6f

Definition at line 23 of file TensorHelpers.hpp.

Referenced by SelectiveComparer< T, false >::Compare().