GitHub #543 Problem Parsing Mixed-Precision Model

 * Fixed bug when converting Constants with Per-Axis Quantization

Signed-off-by: Mike Kelly <mike.kelly@arm.com>
Change-Id: Ifbea23e60483746ec987da491dae96e74cb33af4

2 files changed, 260 insertions, 4 deletions

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<unsigned int> SqueezeDims(const TensorShape& tensorShape)
 {
-    unsigned int outputDimSize = 0;
     std::vector<unsigned int> squeezedDims;
 
     for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
@@ -141,7 +140,6 @@ std::vector<unsigned int> SqueezeDims(const TensorShape& tensorShape)
         if (tensorShape[i] != 1)
         {
             squeezedDims.push_back(tensorShape[i]);
-            ++outputDimSize;
         }
     }
     return squeezedDims;
@@ -201,4 +199,91 @@ std::pair<unsigned int, std::vector<float>> GetPerAxisParams(const armnn::Tensor
     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
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<uint8_t> 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<float> 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<uint8_t> 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<float[]> 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<uint8_t> 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<float[]> 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<float> 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<uint8_t> 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<float[]> 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<uint8_t> 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<float[]> 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<float> 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<uint8_t> 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<float[]> 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<uint8_t> 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<float[]> 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<float> 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<uint8_t> 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<float[]> 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<uint8_t> 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<float[]> 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<float> 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<uint8_t> 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<float[]> 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<uint8_t> 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<float[]> result = ToFloatArray(data, info);
+
+    for (uint i = 0; i < info.GetNumElements(); ++i)
+    {
+        CHECK_EQ(result[i], doctest::Approx(expected[i]));
+    }
+}
 }