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

1 files changed, 172 insertions, 1 deletions

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]));
+    }
+}
 }