ImageTensorGenerator.hpp File Reference

#include "../InferenceTestImage.hpp"
#include <armnn/TypesUtils.hpp>
#include <armnnUtils/Permute.hpp>
#include <algorithm>
#include <fstream>
#include <iterator>
#include <string>

Go to the source code of this file.

Classes
struct	NormalizationParameters

Enumerations
enum	SupportedFrontend { TFLite = 0 }

Functions
NormalizationParameters	GetNormalizationParameters (const SupportedFrontend &modelFormat, const armnn::DataType &outputType)
	Get normalization parameters. More...
template<typename ElemType >
std::vector< ElemType >	PrepareImageTensor (const std::string &imagePath, unsigned int newWidth, unsigned int newHeight, const NormalizationParameters &normParams, unsigned int batchSize=1, const armnn::DataLayout &outputLayout=armnn::DataLayout::NHWC)
	Prepare raw image tensor data by loading the image from imagePath and preprocessing it. More...
template<>
std::vector< float >	PrepareImageTensor< float > (const std::string &imagePath, unsigned int newWidth, unsigned int newHeight, const NormalizationParameters &normParams, unsigned int batchSize, const armnn::DataLayout &outputLayout)
template<>
std::vector< int >	PrepareImageTensor< int > (const std::string &imagePath, unsigned int newWidth, unsigned int newHeight, const NormalizationParameters &normParams, unsigned int batchSize, const armnn::DataLayout &outputLayout)
template<>
std::vector< uint8_t >	PrepareImageTensor< uint8_t > (const std::string &imagePath, unsigned int newWidth, unsigned int newHeight, const NormalizationParameters &normParams, unsigned int batchSize, const armnn::DataLayout &outputLayout)
template<>
std::vector< int8_t >	PrepareImageTensor< int8_t > (const std::string &imagePath, unsigned int newWidth, unsigned int newHeight, const NormalizationParameters &normParams, unsigned int batchSize, const armnn::DataLayout &outputLayout)
template<typename ElemType >
void	WriteImageTensorImpl (const std::vector< ElemType > &imageData, std::ofstream &imageTensorFile)
	Write image tensor to ofstream. More...
template<>
void	WriteImageTensorImpl< uint8_t > (const std::vector< uint8_t > &imageData, std::ofstream &imageTensorFile)
template<>
void	WriteImageTensorImpl< int8_t > (const std::vector< int8_t > &imageData, std::ofstream &imageTensorFile)

Enumeration Type Documentation

SupportedFrontend

enum SupportedFrontend

strong

Enumerator
TFLite

Definition at line 25 of file ImageTensorGenerator.hpp.

{
    TFLite     = 0,
};

Function Documentation

GetNormalizationParameters()

NormalizationParameters GetNormalizationParameters	(	const SupportedFrontend &	modelFormat,
		const armnn::DataType &	outputType
	)

Get normalization parameters.

Note that different flavours of models and different model data types have different normalization methods. This tool currently only supports TF and TFLite models

Parameters

[in]	modelFormat	One of the supported frontends
[in]	outputType	Output type of the image tensor, also the type of the intended model

Definition at line 37 of file ImageTensorGenerator.hpp.

References armnn::Float32, NormalizationParameters::mean, armnn::NHWC, PrepareImageTensor(), armnn::QAsymmS8, armnn::QAsymmU8, NormalizationParameters::scale, armnn::Signed32, NormalizationParameters::stddev, and TFLite.

Referenced by main().

{
    NormalizationParameters normParams;
    // Explicitly set default parameters
    normParams.scale  = 1.0;
    normParams.mean   = { 0.0, 0.0, 0.0 };
    normParams.stddev = { 1.0, 1.0, 1.0 };
    switch (modelFormat)
    {
        case SupportedFrontend::TFLite:
        default:
            switch (outputType)
            {
                case armnn::DataType::Float32:
                    normParams.scale = 127.5;
                    normParams.mean  = { 1.0, 1.0, 1.0 };
                    break;
                case armnn::DataType::Signed32:
                    normParams.mean = { 128.0, 128.0, 128.0 };
                    break;
                case armnn::DataType::QAsymmU8:
                    break;
                case armnn::DataType::QAsymmS8:
                    normParams.mean = { 128.0, 128.0, 128.0 };
                    break;
                default:
                    break;
            }
            break;
    }
    return normParams;
}

PrepareImageTensor()

std::vector<ElemType> PrepareImageTensor	(	const std::string &	imagePath,
		unsigned int	newWidth,
		unsigned int	newHeight,
		const NormalizationParameters &	normParams,
		unsigned int	batchSize = 1,
		const armnn::DataLayout &	outputLayout = armnn::DataLayout::NHWC
	)

Prepare raw image tensor data by loading the image from imagePath and preprocessing it.

Parameters

[in]	imagePath	Path to the image file
[in]	newWidth	The new width of the output image tensor
[in]	newHeight	The new height of the output image tensor
[in]	normParams	Normalization parameters for the normalization of the image
[in]	batchSize	Batch size
[in]	outputLayout	Data layout of the output image tensor

Referenced by GetNormalizationParameters().

PrepareImageTensor< float >()

std::vector<float> PrepareImageTensor< float >	(	const std::string &	imagePath,
		unsigned int	newWidth,
		unsigned int	newHeight,
		const NormalizationParameters &	normParams,
		unsigned int	batchSize,
		const armnn::DataLayout &	outputLayout
	)

Definition at line 90 of file ImageTensorGenerator.hpp.

References InferenceTestImage::BilinearAndNormalized, CHECK_LOCATION, InferenceTestImage::GetWidth(), NormalizationParameters::mean, armnn::NCHW, armnnUtils::NHWCToArmNN, armnnUtils::Permute(), NormalizationParameters::scale, and NormalizationParameters::stddev.

Referenced by main(), PrepareImageTensor< int >(), PrepareImageTensor< int8_t >(), and PrepareImageTensor< uint8_t >().

{
    // Generate image tensor
    std::vector<float> imageData;
    InferenceTestImage testImage(imagePath.c_str());
    if (newWidth == 0)
    {
        newWidth = testImage.GetWidth();
    }
    if (newHeight == 0)
    {
        newHeight = testImage.GetHeight();
    }
    // Resize the image to new width and height or keep at original dimensions if the new width and height are specified
    // as 0 Centre/Normalise the image.
    imageData = testImage.Resize(newWidth, newHeight, CHECK_LOCATION(),
                                 InferenceTestImage::ResizingMethods::BilinearAndNormalized, normParams.mean,
                                 normParams.stddev, normParams.scale);
    if (outputLayout == armnn::DataLayout::NCHW)
    {
        // Convert to NCHW format
        const armnn::PermutationVector NHWCToArmNN = { 0, 2, 3, 1 };
        armnn::TensorShape dstShape({ batchSize, 3, newHeight, newWidth });
        std::vector<float> tempImage(imageData.size());
        armnnUtils::Permute(dstShape, NHWCToArmNN, imageData.data(), tempImage.data(), sizeof(float));
        imageData.swap(tempImage);
    }
    return imageData;
}

PrepareImageTensor< int >()

std::vector<int> PrepareImageTensor< int >	(	const std::string &	imagePath,
		unsigned int	newWidth,
		unsigned int	newHeight,
		const NormalizationParameters &	normParams,
		unsigned int	batchSize,
		const armnn::DataLayout &	outputLayout
	)

Definition at line 127 of file ImageTensorGenerator.hpp.

References PrepareImageTensor< float >().

Referenced by main().

{
    // Get float32 image tensor
    std::vector<float> imageDataFloat =
        PrepareImageTensor<float>(imagePath, newWidth, newHeight, normParams, batchSize, outputLayout);
    // Convert to int32 image tensor with static cast
    std::vector<int> imageDataInt;
    imageDataInt.reserve(imageDataFloat.size());
    std::transform(imageDataFloat.begin(), imageDataFloat.end(), std::back_inserter(imageDataInt),
                   [](float val) { return static_cast<int>(val); });
    return imageDataInt;
}

PrepareImageTensor< int8_t >()

std::vector<int8_t> PrepareImageTensor< int8_t >	(	const std::string &	imagePath,
		unsigned int	newWidth,
		unsigned int	newHeight,
		const NormalizationParameters &	normParams,
		unsigned int	batchSize,
		const armnn::DataLayout &	outputLayout
	)

Definition at line 167 of file ImageTensorGenerator.hpp.

References PrepareImageTensor< float >().

Referenced by main().

{
    // Get float32 image tensor
    std::vector<float> imageDataFloat =
            PrepareImageTensor<float>(imagePath, newWidth, newHeight, normParams, batchSize, outputLayout);
    std::vector<int8_t> imageDataQasymms8;
    imageDataQasymms8.reserve(imageDataFloat.size());
    // Convert to uint8 image tensor with static cast
    std::transform(imageDataFloat.begin(), imageDataFloat.end(), std::back_inserter(imageDataQasymms8),
                   [](float val) { return static_cast<uint8_t>(val); });
    return imageDataQasymms8;
}

PrepareImageTensor< uint8_t >()

std::vector<uint8_t> PrepareImageTensor< uint8_t >	(	const std::string &	imagePath,
		unsigned int	newWidth,
		unsigned int	newHeight,
		const NormalizationParameters &	normParams,
		unsigned int	batchSize,
		const armnn::DataLayout &	outputLayout
	)

Definition at line 147 of file ImageTensorGenerator.hpp.

References PrepareImageTensor< float >().

Referenced by main().

{
    // Get float32 image tensor
    std::vector<float> imageDataFloat =
        PrepareImageTensor<float>(imagePath, newWidth, newHeight, normParams, batchSize, outputLayout);
    std::vector<uint8_t> imageDataQasymm8;
    imageDataQasymm8.reserve(imageDataFloat.size());
    // Convert to uint8 image tensor with static cast
    std::transform(imageDataFloat.begin(), imageDataFloat.end(), std::back_inserter(imageDataQasymm8),
                   [](float val) { return static_cast<uint8_t>(val); });
    return imageDataQasymm8;
}

WriteImageTensorImpl()

void WriteImageTensorImpl	(	const std::vector< ElemType > &	imageData,
		std::ofstream &	imageTensorFile
	)

Write image tensor to ofstream.

Parameters

[in]	imageData	Image tensor data
[in]	imageTensorFile	Output filestream (ofstream) to which the image tensor data is written

Definition at line 191 of file ImageTensorGenerator.hpp.

Referenced by main().

{
    std::copy(imageData.begin(), imageData.end(), std::ostream_iterator<ElemType>(imageTensorFile, " "));
}

WriteImageTensorImpl< int8_t >()

void WriteImageTensorImpl< int8_t >	(	const std::vector< int8_t > &	imageData,
		std::ofstream &	imageTensorFile
	)

Definition at line 207 of file ImageTensorGenerator.hpp.

{
    std::copy(imageData.begin(), imageData.end(), std::ostream_iterator<int>(imageTensorFile, " "));
}

WriteImageTensorImpl< uint8_t >()

void WriteImageTensorImpl< uint8_t >	(	const std::vector< uint8_t > &	imageData,
		std::ofstream &	imageTensorFile
	)

Definition at line 199 of file ImageTensorGenerator.hpp.

{
    std::copy(imageData.begin(), imageData.end(), std::ostream_iterator<int>(imageTensorFile, " "));
}