src/armnnUtils/TensorUtils.cpp - ml/armnn - Gitiles

 //
 // Copyright © 2017-2023 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //

 #include <armnnUtils/TensorUtils.hpp>

 #include <armnn/Exceptions.hpp>

 #include <armnn/backends/ITensorHandle.hpp>
 #include <armnn/utility/Assert.hpp>
 #include <armnn/utility/NumericCast.hpp>

 #include <fmt/format.h>

 using namespace armnn;

 namespace armnnUtils
 {

 TensorShape GetTensorShape(unsigned int numberOfBatches,
                                   unsigned int numberOfChannels,
                                   unsigned int height,
                                   unsigned int width,
                                   const DataLayout dataLayout)
 {
     switch (dataLayout)
     {
         case DataLayout::NCHW:
             return TensorShape({numberOfBatches, numberOfChannels, height, width});
         case DataLayout::NHWC:
             return TensorShape({numberOfBatches, height, width, numberOfChannels});
         default:
             throw InvalidArgumentException("Unknown data layout ["
                                                   + std::to_string(static_cast<int>(dataLayout)) +
                                                   "]", CHECK_LOCATION());
     }
 }

 TensorInfo GetTensorInfo(unsigned int numberOfBatches,
                                 unsigned int numberOfChannels,
                                 unsigned int height,
                                 unsigned int width,
                                 const DataLayout dataLayout,
                                 const DataType dataType)
 {
     switch (dataLayout)
     {
         case DataLayout::NCHW:
             return TensorInfo({numberOfBatches, numberOfChannels, height, width}, dataType);
         case DataLayout::NHWC:
             return TensorInfo({numberOfBatches, height, width, numberOfChannels}, dataType);
         default:
             throw InvalidArgumentException("Unknown data layout ["
                                                   + std::to_string(static_cast<int>(dataLayout)) +
                                                   "]", CHECK_LOCATION());
     }
 }

 TensorInfo GetTensorInfo(unsigned int numberOfBatches,
                                 unsigned int numberOfChannels,
                                 unsigned int depth,
                                 unsigned int height,
                                 unsigned int width,
                                 const DataLayout dataLayout,
                                 const DataType dataType)
 {
     switch (dataLayout)
     {
         case DataLayout::NDHWC:
             return TensorInfo({numberOfBatches, depth, height, width, numberOfChannels}, dataType);
         case DataLayout::NCDHW:
             return TensorInfo({numberOfBatches, numberOfChannels, depth, height, width}, dataType);
         default:
             throw InvalidArgumentException("Unknown data layout ["
                                                   + std::to_string(static_cast<int>(dataLayout)) +
                                                   "]", CHECK_LOCATION());
     }
 }

 std::pair<float, float> FindMinMax(ITensorHandle* tensorHandle)
 {
     auto tensor_data = static_cast<const float *>(tensorHandle->Map(true));
     auto tensor_size = tensorHandle->GetShape().GetNumElements();

     // Set min/max initially to first value in tensor
     float min = tensor_data[0];
     float max = tensor_data[0];

     // Loop over rest of tensor and update min/max if necessary
     for (unsigned int val = 1; val < tensor_size; val++)
     {
         if (tensor_data[val] < min)
         {
             min = tensor_data[val];
         }
         else if (tensor_data[val] > max)
         {
             max = tensor_data[val];
         }
     }

     tensorHandle->Unmap();

     return std::make_pair(min, max);
 }

 TensorShape ReduceDims(const TensorShape& tensorShape, unsigned int dimensions)
 {
     if (tensorShape.GetNumDimensions() <= dimensions)
     {
         return tensorShape;
     }
     std::vector<unsigned int> newShape;

     unsigned int dimsToSkip = tensorShape.GetNumDimensions() - dimensions;
     unsigned int dimsSkipped = 0;
     bool insertRemainder = false;

     for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
     {
         if (tensorShape[i] == 1 && dimsSkipped < dimsToSkip && !insertRemainder)
         {
             ++dimsSkipped;
             continue;
         }
         newShape.push_back(tensorShape[i]);
         // Once we insert the first dimension we can't skip any more
         insertRemainder = true;
     }
     return TensorShape(static_cast<unsigned int>(newShape.size()), newShape.data());
 }

 TensorInfo ReduceDims(const TensorInfo& tensorInfo, unsigned int dimensions)
 {
     TensorInfo strippedTensor(tensorInfo);
     TensorShape strippedShape = ReduceDims(tensorInfo.GetShape(), dimensions);
     strippedTensor.SetShape(strippedShape);
     return strippedTensor;
 }

 TensorShape ExpandDims(const TensorShape& tensorShape, int axis)
 {
     unsigned int outputDim = tensorShape.GetNumDimensions() + 1;

     if (axis < -armnn::numeric_cast<int>(outputDim) || axis > armnn::numeric_cast<int>(tensorShape.GetNumDimensions()))
     {
         throw InvalidArgumentException(fmt::format("Invalid expansion axis {} for {}D input tensor. {}",
                                                    axis,
                                                    tensorShape.GetNumDimensions(),
                                                    CHECK_LOCATION().AsString()));
     }

     if (axis < 0)
     {
         axis = armnn::numeric_cast<int>(outputDim) + axis;
     }

     std::vector<unsigned int> outputShape;
     outputShape.reserve(tensorShape.GetNumDimensions());
     for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
     {
         outputShape.push_back(tensorShape[i]);
     }
     outputShape.insert(outputShape.begin() + axis, 1);

     return { outputDim, outputShape.data() };
 }

 TensorShape ExpandDimsToRank(const TensorShape& tensorShape, unsigned int rank)
 {
     // Can't expand if rank is smaller than current shape
     if (tensorShape.GetNumDimensions() >= rank)
     {
         return tensorShape;
     }

     std::vector<unsigned int> newShape;

     // First add 1s to the beginning of the tensorInfo to fill in the space
     for (unsigned int i = 0; i < rank - tensorShape.GetNumDimensions(); ++i)
     {
         newShape.push_back(1);
     }

     // Then iterate through the original shape and append it to the new shape with the added 1s
     for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
     {
         newShape.push_back(tensorShape[i]);
     }

     return TensorShape(static_cast<unsigned int>(newShape.size()), newShape.data());
 }

 std::vector<unsigned int> SqueezeDims(const TensorShape& tensorShape)
 {
     std::vector<unsigned int> squeezedDims;

     for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
     {
         if (tensorShape[i] != 1)
         {
             squeezedDims.push_back(tensorShape[i]);
         }
     }
     return squeezedDims;
 }

 unsigned int GetNumElementsBetween(const TensorShape& shape,
                                    const unsigned int firstAxisInclusive,
                                    const unsigned int lastAxisExclusive)
 {
     if (firstAxisInclusive > lastAxisExclusive)
     {
         throw armnn::InvalidArgumentException(fmt::format(
             "GetNumElementsBetween: firstAxisInclusive [{}D] is greater than lastAxisExclusive [{}D]",
             firstAxisInclusive,
             lastAxisExclusive));
     }
     if (lastAxisExclusive > shape.GetNumDimensions())
     {
         throw armnn::InvalidArgumentException(fmt::format(
             "{}: lastAxisExclusive [{}D] is greater than the number of dimensions of the tensor shape [{}D]"
             "GetNumElementsBetween",
             lastAxisExclusive,
             shape.GetNumDimensions()));
     }
     unsigned int count = 1;
     for (unsigned int i = firstAxisInclusive; i < lastAxisExclusive; i++)
     {
         count *= shape[i];
     }
     return count;
 }

 unsigned int GetUnsignedAxis(const unsigned int inputDimension, const int axis)
 {
     if (axis >= armnn::numeric_cast<int>(inputDimension))
     {
         throw armnn::InvalidArgumentException(fmt::format(
             "{}: axis index [{}] is not less than the number of dimensions [{}D]",
             "GetUnsignedAxis",
             axis,
             inputDimension));
     }
     if (axis < -armnn::numeric_cast<int>(inputDimension))
     {
         throw armnn::InvalidArgumentException(fmt::format(
             "{}: axis index [{}] lower than the negative of the number of dimensions [{}]",
             "GetUnsignedAxis",
             axis,
             -armnn::numeric_cast<int>(inputDimension)));
     }

     unsigned int uAxis = axis < 0  ?
                          inputDimension - armnn::numeric_cast<unsigned int>(abs(axis))
                          : armnn::numeric_cast<unsigned int>(axis);
     return uAxis;
 }

 unsigned int GetNumElementsAfter(const armnn::TensorShape& shape, unsigned int axis)
 {
     unsigned int numDim = shape.GetNumDimensions();
     if (axis >= numDim)
     {
         throw armnn::InvalidArgumentException(fmt::format(
             "{}: axis index [{}D] indexes beyond the number of dimesions of the tensor shape [{}D]",
             "GetNumElementsAfter",
             axis,
             numDim));
     }
     unsigned int count = 1;
     for (unsigned int i = axis+1; i < numDim; i++)
     {
         count *= shape[i];
     }
     return count;
 }

 std::pair<unsigned int, std::vector<float>> GetPerAxisParams(const armnn::TensorInfo& info)
 {
     const std::vector<float>& scales = info.GetQuantizationScales();
     armnn::Optional<unsigned int> quantizationDim = info.GetQuantizationDim();
     if (!info.HasPerAxisQuantization())
     {
         throw armnn::InvalidArgumentException(
             std::string("Per-axis quantization params not set for tensor of type ") +
             armnn::GetDataTypeName(info.GetDataType()), CHECK_LOCATION());
     }
     unsigned int axisFactor = GetNumElementsAfter(info.GetShape(), quantizationDim.value()) ;

     return { axisFactor, scales };
 }

 template<typename PrimitiveType>
 void CheckSizes(const std::vector<PrimitiveType>& data, const armnn::TensorInfo& tensorInfo, unsigned int size = 1)
 {
     if (data.size() / size != tensorInfo.GetNumElements())
     {
         throw InvalidArgumentException(
                 fmt::format("The data does not contain the expected number of elements {} != {}. {}",
                             data.size(), tensorInfo.GetNumElements(), CHECK_LOCATION().AsString()));
     }
 }

 template<typename PrimitiveType>
 std::unique_ptr<float[]> ToFloatArray(const std::vector<PrimitiveType>& data, const armnn::TensorInfo& tensorInfo)
 {
     CheckSizes(data, tensorInfo);

     std::unique_ptr<float[]> returnBuffer(new float[tensorInfo.GetNumElements()]);

     if (tensorInfo.HasPerAxisQuantization())
     {
         unsigned int axis = tensorInfo.GetQuantizationDim().value();
         auto axisDimensionality = tensorInfo.GetShape()[axis];
         auto axisFactor = armnnUtils::GetNumElementsAfter(tensorInfo.GetShape(), axis);

         for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i)
         {
             unsigned int axisIndex;

             if (i < axisFactor)
             {
                 axisIndex = 0;
             }
             else
             {
                 axisIndex = (i / axisFactor) % axisDimensionality;
             }
             returnBuffer[i] = Dequantize<PrimitiveType>(data[i],
                                                         tensorInfo.GetQuantizationScales()[axisIndex],
                                                         tensorInfo.GetQuantizationOffset());
         }
     }
     else
     {
         for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i)
         {
             returnBuffer[i] = Dequantize<PrimitiveType>(data[i],
                                                         tensorInfo.GetQuantizationScale(),
                                                         tensorInfo.GetQuantizationOffset());
         }
     }
     return returnBuffer;
 }

 std::unique_ptr<float[]> ToFloatArray(const std::vector<uint8_t>& data, const armnn::TensorInfo& tensorInfo)
 {
     if (tensorInfo.GetDataType() == DataType::QAsymmS8 || tensorInfo.GetDataType() == DataType::QSymmS8)
     {
         CheckSizes(data, tensorInfo);
         std::vector<int8_t> buffer(tensorInfo.GetNumElements());
         ::memcpy(buffer.data(), data.data(), data.size());
         return ToFloatArray<int8_t>(buffer, tensorInfo);
     }
     else if (tensorInfo.GetDataType() == DataType::QAsymmU8)
     {
         CheckSizes(data, tensorInfo);
         return ToFloatArray<uint8_t>(data, tensorInfo);
     }
     else if (tensorInfo.GetDataType() == DataType::Signed32)
     {
         CheckSizes(data, tensorInfo, 4);
         std::vector<int32_t> buffer(tensorInfo.GetNumElements());
         ::memcpy(buffer.data(), data.data(), data.size());
         return ToFloatArray<int32_t>(buffer, tensorInfo);
     }
     else if (tensorInfo.GetDataType() == DataType::Signed64)
     {
         CheckSizes(data, tensorInfo, 8);
         std::vector<int64_t> buffer(tensorInfo.GetNumElements());
         ::memcpy(buffer.data(), data.data(), data.size());
         return ToFloatArray<int64_t>(buffer, tensorInfo);
     }
     throw InvalidArgumentException(
             fmt::format("Unsupported datatype {}. {}",
                         GetDataTypeName(tensorInfo.GetDataType()),
                         CHECK_LOCATION().AsString()));
 }

 } // namespace armnnUtils
	//
	// Copyright © 2017-2023 Arm Ltd. All rights reserved.
	// SPDX-License-Identifier: MIT
	//

	#include <armnnUtils/TensorUtils.hpp>

	#include <armnn/Exceptions.hpp>

	#include <armnn/backends/ITensorHandle.hpp>
	#include <armnn/utility/Assert.hpp>
	#include <armnn/utility/NumericCast.hpp>

	#include <fmt/format.h>

	using namespace armnn;

	namespace armnnUtils
	{

	TensorShape GetTensorShape(unsigned int numberOfBatches,
	unsigned int numberOfChannels,
	unsigned int height,
	unsigned int width,
	const DataLayout dataLayout)
	{
	switch (dataLayout)
	{
	case DataLayout::NCHW:
	return TensorShape({numberOfBatches, numberOfChannels, height, width});
	case DataLayout::NHWC:
	return TensorShape({numberOfBatches, height, width, numberOfChannels});
	default:
	throw InvalidArgumentException("Unknown data layout ["
	+ std::to_string(static_cast<int>(dataLayout)) +
	"]", CHECK_LOCATION());
	}
	}

	TensorInfo GetTensorInfo(unsigned int numberOfBatches,
	unsigned int numberOfChannels,
	unsigned int height,
	unsigned int width,
	const DataLayout dataLayout,
	const DataType dataType)
	{
	switch (dataLayout)
	{
	case DataLayout::NCHW:
	return TensorInfo({numberOfBatches, numberOfChannels, height, width}, dataType);
	case DataLayout::NHWC:
	return TensorInfo({numberOfBatches, height, width, numberOfChannels}, dataType);
	default:
	throw InvalidArgumentException("Unknown data layout ["
	+ std::to_string(static_cast<int>(dataLayout)) +
	"]", CHECK_LOCATION());
	}
	}

	TensorInfo GetTensorInfo(unsigned int numberOfBatches,
	unsigned int numberOfChannels,
	unsigned int depth,
	unsigned int height,
	unsigned int width,
	const DataLayout dataLayout,
	const DataType dataType)
	{
	switch (dataLayout)
	{
	case DataLayout::NDHWC:
	return TensorInfo({numberOfBatches, depth, height, width, numberOfChannels}, dataType);
	case DataLayout::NCDHW:
	return TensorInfo({numberOfBatches, numberOfChannels, depth, height, width}, dataType);
	default:
	throw InvalidArgumentException("Unknown data layout ["
	+ std::to_string(static_cast<int>(dataLayout)) +
	"]", CHECK_LOCATION());
	}
	}

	std::pair<float, float> FindMinMax(ITensorHandle* tensorHandle)
	{
	auto tensor_data = static_cast<const float *>(tensorHandle->Map(true));
	auto tensor_size = tensorHandle->GetShape().GetNumElements();

	// Set min/max initially to first value in tensor
	float min = tensor_data[0];
	float max = tensor_data[0];

	// Loop over rest of tensor and update min/max if necessary
	for (unsigned int val = 1; val < tensor_size; val++)
	{
	if (tensor_data[val] < min)
	{
	min = tensor_data[val];
	}
	else if (tensor_data[val] > max)
	{
	max = tensor_data[val];
	}
	}

	tensorHandle->Unmap();

	return std::make_pair(min, max);
	}

	TensorShape ReduceDims(const TensorShape& tensorShape, unsigned int dimensions)
	{
	if (tensorShape.GetNumDimensions() <= dimensions)
	{
	return tensorShape;
	}
	std::vector<unsigned int> newShape;

	unsigned int dimsToSkip = tensorShape.GetNumDimensions() - dimensions;
	unsigned int dimsSkipped = 0;
	bool insertRemainder = false;

	for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
	{
	if (tensorShape[i] == 1 && dimsSkipped < dimsToSkip && !insertRemainder)
	{
	++dimsSkipped;
	continue;
	}
	newShape.push_back(tensorShape[i]);
	// Once we insert the first dimension we can't skip any more
	insertRemainder = true;
	}
	return TensorShape(static_cast<unsigned int>(newShape.size()), newShape.data());
	}

	TensorInfo ReduceDims(const TensorInfo& tensorInfo, unsigned int dimensions)
	{
	TensorInfo strippedTensor(tensorInfo);
	TensorShape strippedShape = ReduceDims(tensorInfo.GetShape(), dimensions);
	strippedTensor.SetShape(strippedShape);
	return strippedTensor;
	}

	TensorShape ExpandDims(const TensorShape& tensorShape, int axis)
	{
	unsigned int outputDim = tensorShape.GetNumDimensions() + 1;

	if (axis < -armnn::numeric_cast<int>(outputDim) \|\| axis > armnn::numeric_cast<int>(tensorShape.GetNumDimensions()))
	{
	throw InvalidArgumentException(fmt::format("Invalid expansion axis {} for {}D input tensor. {}",
	axis,
	tensorShape.GetNumDimensions(),
	CHECK_LOCATION().AsString()));
	}

	if (axis < 0)
	{
	axis = armnn::numeric_cast<int>(outputDim) + axis;
	}

	std::vector<unsigned int> outputShape;
	outputShape.reserve(tensorShape.GetNumDimensions());
	for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
	{
	outputShape.push_back(tensorShape[i]);
	}
	outputShape.insert(outputShape.begin() + axis, 1);

	return { outputDim, outputShape.data() };
	}

	TensorShape ExpandDimsToRank(const TensorShape& tensorShape, unsigned int rank)
	{
	// Can't expand if rank is smaller than current shape
	if (tensorShape.GetNumDimensions() >= rank)
	{
	return tensorShape;
	}

	std::vector<unsigned int> newShape;

	// First add 1s to the beginning of the tensorInfo to fill in the space
	for (unsigned int i = 0; i < rank - tensorShape.GetNumDimensions(); ++i)
	{
	newShape.push_back(1);
	}

	// Then iterate through the original shape and append it to the new shape with the added 1s
	for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
	{
	newShape.push_back(tensorShape[i]);
	}

	return TensorShape(static_cast<unsigned int>(newShape.size()), newShape.data());
	}

	std::vector<unsigned int> SqueezeDims(const TensorShape& tensorShape)
	{
	std::vector<unsigned int> squeezedDims;

	for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
	{
	if (tensorShape[i] != 1)
	{
	squeezedDims.push_back(tensorShape[i]);
	}
	}
	return squeezedDims;
	}

	unsigned int GetNumElementsBetween(const TensorShape& shape,
	const unsigned int firstAxisInclusive,
	const unsigned int lastAxisExclusive)
	{
	if (firstAxisInclusive > lastAxisExclusive)
	{
	throw armnn::InvalidArgumentException(fmt::format(
	"GetNumElementsBetween: firstAxisInclusive [{}D] is greater than lastAxisExclusive [{}D]",
	firstAxisInclusive,
	lastAxisExclusive));
	}
	if (lastAxisExclusive > shape.GetNumDimensions())
	{
	throw armnn::InvalidArgumentException(fmt::format(
	"{}: lastAxisExclusive [{}D] is greater than the number of dimensions of the tensor shape [{}D]"
	"GetNumElementsBetween",
	lastAxisExclusive,
	shape.GetNumDimensions()));
	}
	unsigned int count = 1;
	for (unsigned int i = firstAxisInclusive; i < lastAxisExclusive; i++)
	{
	count *= shape[i];
	}
	return count;
	}

	unsigned int GetUnsignedAxis(const unsigned int inputDimension, const int axis)
	{
	if (axis >= armnn::numeric_cast<int>(inputDimension))
	{
	throw armnn::InvalidArgumentException(fmt::format(
	"{}: axis index [{}] is not less than the number of dimensions [{}D]",
	"GetUnsignedAxis",
	axis,
	inputDimension));
	}
	if (axis < -armnn::numeric_cast<int>(inputDimension))
	{
	throw armnn::InvalidArgumentException(fmt::format(
	"{}: axis index [{}] lower than the negative of the number of dimensions [{}]",
	"GetUnsignedAxis",
	axis,
	-armnn::numeric_cast<int>(inputDimension)));
	}

	unsigned int uAxis = axis < 0 ?
	inputDimension - armnn::numeric_cast<unsigned int>(abs(axis))
	: armnn::numeric_cast<unsigned int>(axis);
	return uAxis;
	}

	unsigned int GetNumElementsAfter(const armnn::TensorShape& shape, unsigned int axis)
	{
	unsigned int numDim = shape.GetNumDimensions();
	if (axis >= numDim)
	{
	throw armnn::InvalidArgumentException(fmt::format(
	"{}: axis index [{}D] indexes beyond the number of dimesions of the tensor shape [{}D]",
	"GetNumElementsAfter",
	axis,
	numDim));
	}
	unsigned int count = 1;
	for (unsigned int i = axis+1; i < numDim; i++)
	{
	count *= shape[i];
	}
	return count;
	}

	std::pair<unsigned int, std::vector<float>> GetPerAxisParams(const armnn::TensorInfo& info)
	{
	const std::vector<float>& scales = info.GetQuantizationScales();
	armnn::Optional<unsigned int> quantizationDim = info.GetQuantizationDim();
	if (!info.HasPerAxisQuantization())
	{
	throw armnn::InvalidArgumentException(
	std::string("Per-axis quantization params not set for tensor of type ") +
	armnn::GetDataTypeName(info.GetDataType()), CHECK_LOCATION());
	}
	unsigned int axisFactor = GetNumElementsAfter(info.GetShape(), quantizationDim.value()) ;

	return { axisFactor, scales };
	}

	template<typename PrimitiveType>
	void CheckSizes(const std::vector<PrimitiveType>& data, const armnn::TensorInfo& tensorInfo, unsigned int size = 1)
	{
	if (data.size() / size != tensorInfo.GetNumElements())
	{
	throw InvalidArgumentException(
	fmt::format("The data does not contain the expected number of elements {} != {}. {}",
	data.size(), tensorInfo.GetNumElements(), CHECK_LOCATION().AsString()));
	}
	}

	template<typename PrimitiveType>
	std::unique_ptr<float[]> ToFloatArray(const std::vector<PrimitiveType>& data, const armnn::TensorInfo& tensorInfo)
	{
	CheckSizes(data, tensorInfo);

	std::unique_ptr<float[]> returnBuffer(new float[tensorInfo.GetNumElements()]);

	if (tensorInfo.HasPerAxisQuantization())
	{
	unsigned int axis = tensorInfo.GetQuantizationDim().value();
	auto axisDimensionality = tensorInfo.GetShape()[axis];
	auto axisFactor = armnnUtils::GetNumElementsAfter(tensorInfo.GetShape(), axis);

	for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i)
	{
	unsigned int axisIndex;

	if (i < axisFactor)
	{
	axisIndex = 0;
	}
	else
	{
	axisIndex = (i / axisFactor) % axisDimensionality;
	}
	returnBuffer[i] = Dequantize<PrimitiveType>(data[i],
	tensorInfo.GetQuantizationScales()[axisIndex],
	tensorInfo.GetQuantizationOffset());
	}
	}
	else
	{
	for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i)
	{
	returnBuffer[i] = Dequantize<PrimitiveType>(data[i],
	tensorInfo.GetQuantizationScale(),
	tensorInfo.GetQuantizationOffset());
	}
	}
	return returnBuffer;
	}

	std::unique_ptr<float[]> ToFloatArray(const std::vector<uint8_t>& data, const armnn::TensorInfo& tensorInfo)
	{
	if (tensorInfo.GetDataType() == DataType::QAsymmS8 \|\| tensorInfo.GetDataType() == DataType::QSymmS8)
	{
	CheckSizes(data, tensorInfo);
	std::vector<int8_t> buffer(tensorInfo.GetNumElements());
	::memcpy(buffer.data(), data.data(), data.size());
	return ToFloatArray<int8_t>(buffer, tensorInfo);
	}
	else if (tensorInfo.GetDataType() == DataType::QAsymmU8)
	{
	CheckSizes(data, tensorInfo);
	return ToFloatArray<uint8_t>(data, tensorInfo);
	}
	else if (tensorInfo.GetDataType() == DataType::Signed32)
	{
	CheckSizes(data, tensorInfo, 4);
	std::vector<int32_t> buffer(tensorInfo.GetNumElements());
	::memcpy(buffer.data(), data.data(), data.size());
	return ToFloatArray<int32_t>(buffer, tensorInfo);
	}
	else if (tensorInfo.GetDataType() == DataType::Signed64)
	{
	CheckSizes(data, tensorInfo, 8);
	std::vector<int64_t> buffer(tensorInfo.GetNumElements());
	::memcpy(buffer.data(), data.data(), data.size());
	return ToFloatArray<int64_t>(buffer, tensorInfo);
	}
	throw InvalidArgumentException(
	fmt::format("Unsupported datatype {}. {}",
	GetDataTypeName(tensorInfo.GetDataType()),
	CHECK_LOCATION().AsString()));
	}

	} // namespace armnnUtils