From 0506ef0a099f5ba564af5e110e6857a68f462080 Mon Sep 17 00:00:00 2001 From: Mike Kelly Date: Tue, 3 Jan 2023 16:29:44 +0000 Subject: GitHub #543 Problem Parsing Mixed-Precision Model * Fixed bug when converting Constants with Per-Axis Quantization Signed-off-by: Mike Kelly Change-Id: Ifbea23e60483746ec987da491dae96e74cb33af4 --- src/armnnUtils/TensorUtils.cpp | 91 ++++++++++++++++- src/armnnUtils/test/TensorUtilsTest.cpp | 173 +++++++++++++++++++++++++++++++- 2 files changed, 260 insertions(+), 4 deletions(-) (limited to 'src/armnnUtils') diff --git a/src/armnnUtils/TensorUtils.cpp b/src/armnnUtils/TensorUtils.cpp index d77f5d74c3..9e3d719211 100644 --- a/src/armnnUtils/TensorUtils.cpp +++ b/src/armnnUtils/TensorUtils.cpp @@ -128,12 +128,11 @@ TensorShape ExpandDims(const TensorShape& tensorShape, int axis) } outputShape.insert(outputShape.begin() + axis, 1); - return TensorShape(outputDim, outputShape.data()); + return { outputDim, outputShape.data() }; } std::vector SqueezeDims(const TensorShape& tensorShape) { - unsigned int outputDimSize = 0; std::vector squeezedDims; for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i) @@ -141,7 +140,6 @@ std::vector SqueezeDims(const TensorShape& tensorShape) if (tensorShape[i] != 1) { squeezedDims.push_back(tensorShape[i]); - ++outputDimSize; } } return squeezedDims; @@ -201,4 +199,91 @@ std::pair> GetPerAxisParams(const armnn::Tensor return { axisFactor, scales }; } +template +void CheckSizes(const std::vector& 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 +std::unique_ptr ToFloatArray(const std::vector& data, const armnn::TensorInfo& tensorInfo) +{ + CheckSizes(data, tensorInfo); + + std::unique_ptr 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(data[i], + tensorInfo.GetQuantizationScales()[axisIndex], + tensorInfo.GetQuantizationOffset()); + } + } + else + { + for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i) + { + returnBuffer[i] = Dequantize(data[i], + tensorInfo.GetQuantizationScale(), + tensorInfo.GetQuantizationOffset()); + } + } + return returnBuffer; +} + +std::unique_ptr ToFloatArray(const std::vector& data, const armnn::TensorInfo& tensorInfo) +{ + if (tensorInfo.GetDataType() == DataType::QAsymmS8 || tensorInfo.GetDataType() == DataType::QSymmS8) + { + CheckSizes(data, tensorInfo); + std::vector buffer(tensorInfo.GetNumElements()); + ::memcpy(buffer.data(), data.data(), data.size()); + return ToFloatArray(buffer, tensorInfo); + } + else if (tensorInfo.GetDataType() == DataType::QAsymmU8) + { + CheckSizes(data, tensorInfo); + return ToFloatArray(data, tensorInfo); + } + else if (tensorInfo.GetDataType() == DataType::Signed32) + { + CheckSizes(data, tensorInfo, 4); + std::vector buffer(tensorInfo.GetNumElements()); + ::memcpy(buffer.data(), data.data(), data.size()); + return ToFloatArray(buffer, tensorInfo); + } + else if (tensorInfo.GetDataType() == DataType::Signed64) + { + CheckSizes(data, tensorInfo, 8); + std::vector buffer(tensorInfo.GetNumElements()); + ::memcpy(buffer.data(), data.data(), data.size()); + return ToFloatArray(buffer, tensorInfo); + } + throw InvalidArgumentException( + fmt::format("Unsupported datatype {}. {}", + GetDataTypeName(tensorInfo.GetDataType()), + CHECK_LOCATION().AsString())); +} + } // namespace armnnUtils diff --git a/src/armnnUtils/test/TensorUtilsTest.cpp b/src/armnnUtils/test/TensorUtilsTest.cpp index 6d5f719eb1..16349c554e 100644 --- a/src/armnnUtils/test/TensorUtilsTest.cpp +++ b/src/armnnUtils/test/TensorUtilsTest.cpp @@ -1,5 +1,5 @@ // -// Copyright © 2019 Arm Ltd. All rights reserved. +// Copyright © 2019,2021-2022 Arm Ltd and Contributors. All rights reserved. // SPDX-License-Identifier: MIT // @@ -134,4 +134,175 @@ TEST_CASE("ExpandDimsInvalidNegativeAxisTest") CHECK_THROWS_AS(ExpandDims(inputShape, -5), armnn::InvalidArgumentException); } +TEST_CASE("ToFloatArrayInvalidDataType") +{ + armnn::TensorInfo info({ 2, 3, 4 }, armnn::DataType::BFloat16); + std::vector data {1,2,3,4,5,6,7,8,9,10}; + + // Invalid argument + CHECK_THROWS_AS(ToFloatArray(data, info), armnn::InvalidArgumentException); +} + +TEST_CASE("ToFloatArrayQSymmS8PerAxis") +{ + std::vector quantizationScales { 0.1f, 0.2f, 0.3f, 0.4f }; + unsigned int quantizationDim = 1; + + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::QSymmS8, quantizationScales, quantizationDim); + std::vector data { 100, 120, 130, 140, 150, 160, 170 ,180, 190, 200, 210, 220 }; + float expected[] { 10.0f, 24.0f, -37.8f, -46.4f, -10.6f, -19.2f, -25.8f, -30.4f, -6.6f, -11.2f, -13.8f, -14.4f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArrayQSymmS8") +{ + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::QSymmS8, 0.1f); + std::vector data { 100, 120, 130, 140, 150, 160, 170 ,180, 190, 200, 210, 220 }; + float expected[] { 10.0f, 12.0f, -12.6f, -11.6f, -10.6f, -9.6f, -8.6f, -7.6f, -6.6f, -5.6f, -4.6f, -3.6f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArrayQAsymmS8PerAxis") +{ + std::vector quantizationScales { 0.1f, 0.2f, 0.3f, 0.4f }; + unsigned int quantizationDim = 1; + + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::QAsymmS8, quantizationScales, quantizationDim); + std::vector data { 100, 120, 130, 140, 150, 160, 170 ,180, 190, 200, 210, 220 }; + float expected[] { 10.0f, 24.0f, -37.8f, -46.4f, -10.6f, -19.2f, -25.8f, -30.4f, -6.6f, -11.2f, -13.8f, -14.4f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArrayQAsymmS8") +{ + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::QAsymmS8, 0.1f); + std::vector data { 100, 120, 130, 140, 150, 160, 170 ,180, 190, 200, 210, 220 }; + float expected[] { 10.0f, 12.0f, -12.6f, -11.6f, -10.6f, -9.6f, -8.6f, -7.6f, -6.6f, -5.6f, -4.6f, -3.6f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArrayQASymmU8PerAxis") +{ + std::vector quantizationScales { 0.1f, 0.2f, 0.3f, 0.4f }; + unsigned int quantizationDim = 1; + + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::QAsymmU8, quantizationScales, quantizationDim); + std::vector data { 100, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220 }; + float expected[] { 10.0f, 24.0f, 39.0f, 56.0f, 15.0f, 32.0f, 51.0f, 72.0f, 19.0f, 40.0f, 63.0f, 88.0f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArrayQAsymmU8") +{ + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::QAsymmU8, 0.1f); + std::vector data { 100, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220 }; + float expected[] { 10.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArraySigned32PerAxis") +{ + std::vector quantizationScales { 0.1f, 0.2f, 0.3f, 0.4f }; + unsigned int quantizationDim = 1; + + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::Signed32, quantizationScales, quantizationDim); + std::vector data { 100, 0, 0, 0, 120, 0, 0, 0, 130, 0, 0, 0, 140, 0, 0, 0, 150, 0, 0, 0, 160, 0, 0, 0, + 170, 0, 0, 0, 180, 0, 0, 0, 190, 0, 0, 0, 200, 0, 0, 0, 210, 0, 0, 0, 220, 0, 0, 0 }; + float expected[] { 10.0f, 24.0f, 39.0f, 56.0f, 15.0f, 32.0f, 51.0f, 72.0f, 19.0f, 40.0f, 63.0f, 88.0f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArraySigned32") +{ + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::Signed32, 0.1f); + std::vector data { 100, 0, 0, 0, 120, 0, 0, 0, 130, 0, 0, 0, 140, 0, 0, 0, 150, 0, 0, 0, 160, 0, 0, 0, + 170, 0, 0, 0, 180, 0, 0, 0, 190, 0, 0, 0, 200, 0, 0, 0, 210, 0, 0, 0, 220, 0, 0, 0 }; + float expected[] { 10.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArraySigned64PerAxis") +{ + std::vector quantizationScales { 0.1f, 0.2f, 0.3f, 0.4f }; + unsigned int quantizationDim = 1; + + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::Signed64, quantizationScales, quantizationDim); + std::vector data { 100, 0, 0, 0, 0, 0, 0, 0, 120, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 0, 0, 0, 0, 160, 0, 0, 0, 0, 0, 0, 0, + 170, 0, 0, 0, 0, 0, 0, 0, 180, 0, 0, 0, 0, 0, 0, 0, 190, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 0, 0, 0, 0, 0, 210, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0 }; + float expected[] { 10.0f, 24.0f, 39.0f, 56.0f, 15.0f, 32.0f, 51.0f, 72.0f, 19.0f, 40.0f, 63.0f, 88.0f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} + +TEST_CASE("ToFloatArraySigned64") +{ + armnn::TensorInfo info({ 3, 4 }, armnn::DataType::Signed64, 0.1f); + std::vector data { 100, 0, 0, 0, 0, 0, 0, 0, 120, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 0, 0, 0, 0, 160, 0, 0, 0, 0, 0, 0, 0, + 170, 0, 0, 0, 0, 0, 0, 0, 180, 0, 0, 0, 0, 0, 0, 0, 190, 0, 0, 0, 0, 0, 0, 0, + 200, 0, 0, 0, 0, 0, 0, 0, 210, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0 }; + float expected[] { 10.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f }; + + std::unique_ptr result = ToFloatArray(data, info); + + for (uint i = 0; i < info.GetNumElements(); ++i) + { + CHECK_EQ(result[i], doctest::Approx(expected[i])); + } +} } -- cgit v1.2.1