IVGCVSW-7296 REDUCE_PROD tests fail when using Tf 2.10

* In TF what ArmNN calls quantized data types can be non-quantized as well.
* This patch creates 2 models:
     * ArmNN: model where int8 and uint8 will always be quantized, but scale can be 1 and offset 0
     * TFLite: model where int8 and uint8 can be quantized and non-quantized


Signed-off-by: Teresa Charlin <teresa.charlinreyes@arm.com>
Change-Id: Id960f2f30988f2bbec88cb4e0c52c189ac957bae

3 files changed, 78 insertions, 43 deletions

diff --git a/delegate/src/test/ReduceTest.cpp b/delegate/src/test/ReduceTest.cpp
index b81c5df592..9c11c8736c 100644
--- a/delegate/src/test/ReduceTest.cpp
+++ b/delegate/src/test/ReduceTest.cpp
@@ -354,8 +354,7 @@ TEST_CASE ("Sum_Fp32_GpuAcc_Test")
 TEST_SUITE("Prod_CpuRefTests")
 {
 
-TEST_CASE ("Prod_Uint8_KeepDims_CpuRef_Test"
-           * doctest::skip(true) )
+TEST_CASE ("Prod_Uint8_KeepDims_CpuRef_Test")
 {
     std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
     std::vector<uint8_t> expectedOutputValues { 4, 6, 3 };
@@ -364,8 +363,7 @@ TEST_CASE ("Prod_Uint8_KeepDims_CpuRef_Test"
                             expectedOutputValues);
 }
 
-TEST_CASE ("Prod_Fp32_CpuRef_Test"
-           * doctest::skip(true) )
+TEST_CASE ("Prod_Fp32_CpuRef_Test")
 {
     std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
     std::vector<float>   expectedOutputValues { 10010.0f, 11022.0f, 12036.0f };
@@ -379,8 +377,7 @@ TEST_CASE ("Prod_Fp32_CpuRef_Test"
 TEST_SUITE("Prod_CpuAccTests")
 {
 
-TEST_CASE ("Prod_Uint8_KeepDims_CpuAcc_Test"
-           * doctest::skip(true) )
+TEST_CASE ("Prod_Uint8_KeepDims_CpuAcc_Test" )
 {
     std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
     std::vector<uint8_t> expectedOutputValues { 4, 6, 3 };
@@ -389,8 +386,7 @@ TEST_CASE ("Prod_Uint8_KeepDims_CpuAcc_Test"
                             expectedOutputValues);
 }
 
-TEST_CASE ("Prod_Fp32_CpuAcc_Test"
-           * doctest::skip(true) )
+TEST_CASE ("Prod_Fp32_CpuAcc_Test")
 {
     std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
     std::vector<float>   expectedOutputValues { 10010.0f, 11022.0f, 12036.0f };
@@ -404,8 +400,7 @@ TEST_CASE ("Prod_Fp32_CpuAcc_Test"
 TEST_SUITE("Prod_GpuAccTests")
 {
 
-TEST_CASE ("Prod_Uint8_KeepDims_GpuAcc_Test"
-           * doctest::skip(true) )
+TEST_CASE ("Prod_Uint8_KeepDims_GpuAcc_Test")
 {
     std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
     std::vector<uint8_t> expectedOutputValues { 4, 6, 3 };
@@ -414,8 +409,7 @@ TEST_CASE ("Prod_Uint8_KeepDims_GpuAcc_Test"
                             expectedOutputValues);
 }
 
-TEST_CASE ("Prod_Fp32_GpuAcc_Test"
-           * doctest::skip(true) )
+TEST_CASE ("Prod_Fp32_GpuAcc_Test")
 {
     std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
     std::vector<float>   expectedOutputValues { 10010.0f, 11022.0f, 12036.0f };
diff --git a/delegate/src/test/ReduceTestHelper.hpp b/delegate/src/test/ReduceTestHelper.hpp
index b41fcfa39b..5457adbd0f 100644
--- a/delegate/src/test/ReduceTestHelper.hpp
+++ b/delegate/src/test/ReduceTestHelper.hpp
@@ -24,14 +24,15 @@ namespace
 {
 
 std::vector<char> CreateReduceTfLiteModel(tflite::BuiltinOperator reduceOperatorCode,
-                                        tflite::TensorType tensorType,
-                                        std::vector<int32_t>& input0TensorShape,
-                                        std::vector<int32_t>& input1TensorShape,
-                                        const std::vector <int32_t>& outputTensorShape,
-                                        std::vector<int32_t>& axisData,
-                                        const bool keepDims,
-                                        float quantScale = 1.0f,
-                                        int quantOffset  = 0)
+                                          tflite::TensorType tensorType,
+                                          std::vector<int32_t>& input0TensorShape,
+                                          std::vector<int32_t>& input1TensorShape,
+                                          const std::vector <int32_t>& outputTensorShape,
+                                          std::vector<int32_t>& axisData,
+                                          const bool keepDims,
+                                          float quantScale = 1.0f,
+                                          int quantOffset  = 0,
+                                          bool kTfLiteNoQuantizationForQuantized = false)
 {
     using namespace tflite;
     flatbuffers::FlatBufferBuilder flatBufferBuilder;
@@ -42,12 +43,38 @@ std::vector<char> CreateReduceTfLiteModel(tflite::BuiltinOperator reduceOperator
                               flatBufferBuilder.CreateVector(reinterpret_cast<const uint8_t*>(axisData.data()),
                                                              sizeof(int32_t) * axisData.size()));
 
-    auto quantizationParameters =
-            CreateQuantizationParameters(flatBufferBuilder,
-                                         0,
-                                         0,
-                                         flatBufferBuilder.CreateVector<float>({ quantScale }),
-                                         flatBufferBuilder.CreateVector<int64_t>({ quantOffset }));
+    flatbuffers::Offset<tflite::QuantizationParameters> quantizationParametersAxis
+    = CreateQuantizationParameters(flatBufferBuilder);
+
+    flatbuffers::Offset<tflite::QuantizationParameters> quantizationParameters;
+
+    if (kTfLiteNoQuantizationForQuantized)
+    {
+        if ((quantScale == 1 || quantScale == 0) && quantOffset == 0)
+        {
+            // Creates quantization parameter with quantization.type = kTfLiteNoQuantization
+            quantizationParameters = CreateQuantizationParameters(flatBufferBuilder);
+        }
+        else
+        {
+            // Creates quantization parameter with quantization.type != kTfLiteNoQuantization
+            quantizationParameters = CreateQuantizationParameters(
+                    flatBufferBuilder,
+                    0,
+                    0,
+                    flatBufferBuilder.CreateVector<float>({quantScale}),
+                    flatBufferBuilder.CreateVector<int64_t>({quantOffset}));
+        }
+    }
+    else
+    {
+        quantizationParameters = CreateQuantizationParameters(
+                flatBufferBuilder,
+                0,
+                0,
+                flatBufferBuilder.CreateVector<float>({quantScale}),
+                flatBufferBuilder.CreateVector<int64_t>({quantOffset}));
+    }
 
     std::array<flatbuffers::Offset<Tensor>, 3> tensors;
     tensors[0] = CreateTensor(flatBufferBuilder,
@@ -64,7 +91,7 @@ std::vector<char> CreateReduceTfLiteModel(tflite::BuiltinOperator reduceOperator
                               ::tflite::TensorType_INT32,
                               1,
                               flatBufferBuilder.CreateString("axis"),
-                              quantizationParameters);
+                              quantizationParametersAxis);
 
     // Create output tensor
     tensors[2] = CreateTensor(flatBufferBuilder,
@@ -75,7 +102,7 @@ std::vector<char> CreateReduceTfLiteModel(tflite::BuiltinOperator reduceOperator
                               flatBufferBuilder.CreateString("output"),
                               quantizationParameters);
 
-    // Create operator. Reduce operations MIN, MAX, SUM, MEAN uses ReducerOptions.
+    // Create operator. Reduce operations MIN, MAX, SUM, MEAN, PROD uses ReducerOptions.
     tflite::BuiltinOptions operatorBuiltinOptionsType = tflite::BuiltinOptions_ReducerOptions;
     flatbuffers::Offset<void> operatorBuiltinOptions = CreateReducerOptions(flatBufferBuilder, keepDims).Union();
 
@@ -131,27 +158,39 @@ void ReduceTest(tflite::BuiltinOperator reduceOperatorCode,
                 int quantOffset  = 0)
 {
     using namespace tflite;
-    std::vector<char> modelBuffer = CreateReduceTfLiteModel(reduceOperatorCode,
-                                                            tensorType,
-                                                            input0Shape,
-                                                            input1Shape,
-                                                            expectedOutputShape,
-                                                            input1Values,
-                                                            keepDims,
-                                                            quantScale,
-                                                            quantOffset);
-
-    const Model* tfLiteModel = GetModel(modelBuffer.data());
+    std::vector<char> modelBufferArmNN = CreateReduceTfLiteModel(reduceOperatorCode,
+                                                                 tensorType,
+                                                                 input0Shape,
+                                                                 input1Shape,
+                                                                 expectedOutputShape,
+                                                                 input1Values,
+                                                                 keepDims,
+                                                                 quantScale,
+                                                                 quantOffset,
+                                                                 false);
+    std::vector<char> modelBufferTFLite = CreateReduceTfLiteModel(reduceOperatorCode,
+                                                                  tensorType,
+                                                                  input0Shape,
+                                                                  input1Shape,
+                                                                  expectedOutputShape,
+                                                                  input1Values,
+                                                                  keepDims,
+                                                                  quantScale,
+                                                                  quantOffset,
+                                                                  true);
+
+    const Model* tfLiteModelArmNN = GetModel(modelBufferArmNN.data());
+    const Model* tfLiteModelTFLite = GetModel(modelBufferTFLite.data());
 
     // Create TfLite Interpreters
     std::unique_ptr<Interpreter> armnnDelegateInterpreter;
-    CHECK(InterpreterBuilder(tfLiteModel, ::tflite::ops::builtin::BuiltinOpResolver())
+    CHECK(InterpreterBuilder(tfLiteModelArmNN, ::tflite::ops::builtin::BuiltinOpResolver())
                   (&armnnDelegateInterpreter) == kTfLiteOk);
     CHECK(armnnDelegateInterpreter != nullptr);
     CHECK(armnnDelegateInterpreter->AllocateTensors() == kTfLiteOk);
 
     std::unique_ptr<Interpreter> tfLiteInterpreter;
-    CHECK(InterpreterBuilder(tfLiteModel, ::tflite::ops::builtin::BuiltinOpResolver())
+    CHECK(InterpreterBuilder(tfLiteModelTFLite, ::tflite::ops::builtin::BuiltinOpResolver())
                   (&tfLiteInterpreter) == kTfLiteOk);
     CHECK(tfLiteInterpreter != nullptr);
     CHECK(tfLiteInterpreter->AllocateTensors() == kTfLiteOk);
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index d3ce7ab62c..9d00a69518 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -574,8 +574,10 @@ bool CheckScaleSetOnQuantizedType(Layer* layer, Optional<std::vector<std::string
     for (unsigned int i = 0; i < numOutputs; i++) {
         OutputSlot& outputSlot = layer->GetOutputSlot(i);
         TensorInfo info = outputSlot.GetTensorInfo();
-        if (DataType::QAsymmU8 == info.GetDataType()) {
-            if (0.f == info.GetQuantizationScale()) {
+        if (DataType::QAsymmU8 == info.GetDataType())
+        {
+            if (0.f == info.GetQuantizationScale())
+            {
                 noErrors = false;
                 std::stringstream ss;
                 ss << "output " << i << " of layer " << GetLayerTypeAsCString(layer->GetType())