Main Compliance testing support for AVG_POOL2D

Fix test set 4 to have more symmetrical data set for AVG_POOL2D.
Increased size of AVG_POOL2D test shapes to meet MIN_DOT_PRODUCTS.
Print out sign of bias magnitude in verify library to help debugging.

Signed-off-by: Jeremy Johnson <jeremy.johnson@arm.com>
Change-Id: Icf139cf5788cbc68f2c537567bdfb4cfe31274df

7 files changed, 160 insertions, 36 deletions

diff --git a/reference_model/src/generate/generate_dot_product.cc b/reference_model/src/generate/generate_dot_product.cc
index 0930956..4054472 100644
--- a/reference_model/src/generate/generate_dot_product.cc
+++ b/reference_model/src/generate/generate_dot_product.cc
@@ -327,6 +327,55 @@ bool generateFullyConnected(const TosaReference::GenerateConfig& cfg,
             return false;
     }
 }
+//---------------------------------------------------------------------------//
+//                              Avg Pool 2D                                   //
+//---------------------------------------------------------------------------//
+
+bool generateAvgPool2D(const TosaReference::GenerateConfig& cfg,
+                       TosaReference::IDotProductGenerator& generator,
+                       void* data,
+                       size_t size)
+{
+    if (cfg.dataType != DType::DType_FP32)
+    {
+        WARNING("[Generator][DP][AvgPool2D] Only supports FP32.");
+        return false;
+    }
+    if (cfg.inputPos != 0)
+    {
+        WARNING("[Generator][DP][AvgPool2D] Invalid input tensor slot position to operator.");
+        return false;
+    }
+    if (cfg.dotProductInfo.kernel.size() != 2 || cfg.dotProductInfo.kernel[0] <= 0 || cfg.dotProductInfo.kernel[1] <= 0)
+    {
+        WARNING("[Generator][DP][AvgPool2D] Missing or incorrect kernel size information.");
+        return false;
+    }
+    if (cfg.shape.size() != 4)
+    {
+        WARNING("[Generator][DP][AvgPool2D] Tensor shape expected 4 dimensions.");
+        return false;
+    }
+
+    float* input      = reinterpret_cast<float*>(data);
+    const int64_t T   = TosaReference::numElementsFromShape(cfg.shape);
+    const uint32_t IH = cfg.shape[1];
+    const uint32_t IW = cfg.shape[2];
+    const uint32_t C  = cfg.shape[3];
+    const uint32_t KY = cfg.dotProductInfo.kernel[0];
+    const uint32_t KX = cfg.dotProductInfo.kernel[1];
+
+    for (int64_t t = 0; t < T; ++t)
+    {
+        uint32_t c  = t % C;
+        uint32_t ix = (t / C) % IW;
+        uint32_t iy = ((t / C) / IW) % IH;
+        uint32_t k  = ((iy % KY) * KX + (ix % KX)) * C + c;
+
+        input[t] = generator(k);
+    }
+    return true;
+}
 }    // namespace
 
 namespace TosaReference
@@ -352,6 +401,8 @@ bool generateDotProduct(const GenerateConfig& cfg, void* data, size_t size)
             return generateReduceSum(cfg, *generator, data, size);
         case tosa::Op_FULLY_CONNECTED:
             return generateFullyConnected(cfg, *generator, data, size);
+        case tosa::Op_AVG_POOL2D:
+            return generateAvgPool2D(cfg, *generator, data, size);
         default:
             WARNING("[Generator][DP] Unsupported operator.");
             return false;
diff --git a/reference_model/src/generate/generate_dot_product_states.cc b/reference_model/src/generate/generate_dot_product_states.cc
index 53bef3a..9ce32ff 100644
--- a/reference_model/src/generate/generate_dot_product_states.cc
+++ b/reference_model/src/generate/generate_dot_product_states.cc
@@ -209,9 +209,23 @@ public:
         const float s0 = _set_data0();
         const float s1 = _set_data1();
         if (_p == P0)
-            return (k == _KS / 2) ? +0.5f : s0 < 0 ? 0.f : (_B / std::sqrt(_KS)) * s1;
+            if (k == _KS / 2)
+            {
+                return s0 < 0 ? -0.5f : +0.5f;
+            }
+            else
+            {
+                return s0 < 0 ? 0.f : (_B / std::sqrt(_KS)) * s1;
+            }
         else if (_p == P1)
-            return (k == _KS / 2) ? -0.5f : s0 < 0 ? (_B / std::sqrt(_KS)) * s1 : 0.f;
+            if (k == _KS / 2)
+            {
+                return s0 < 0 ? +0.5f : -0.5f;
+            }
+            else
+            {
+                return s0 < 0 ? (_B / std::sqrt(_KS)) * s1 : 0.f;
+            }
         else
             return 0.f;
     }
diff --git a/reference_model/src/generate/generate_utils.cc b/reference_model/src/generate/generate_utils.cc
index 3b00ba1..5546269 100644
--- a/reference_model/src/generate/generate_utils.cc
+++ b/reference_model/src/generate/generate_utils.cc
@@ -41,6 +41,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(Op,
                                  { Op::Op_ABS, "ABS" },
                                  { Op::Op_ADD, "ADD" },
                                  { Op::Op_ARGMAX, "ARGMAX" },
+                                 { Op::Op_AVG_POOL2D, "AVG_POOL2D" },
                                  { Op::Op_CEIL, "CEIL" },
                                  { Op::Op_CONV2D, "CONV2D" },
                                  { Op::Op_EXP, "EXP" },
diff --git a/reference_model/src/verify/verify_dot_product.cc b/reference_model/src/verify/verify_dot_product.cc
index 863640f..15de427 100644
--- a/reference_model/src/verify/verify_dot_product.cc
+++ b/reference_model/src/verify/verify_dot_product.cc
@@ -86,10 +86,9 @@ bool validateData(const double* ref, const double* bnd, const AccType* imp, size
     if (S >= 3 && S <= 5)
     {
         const double max_bias = 2 * sqrt(KS * T);
-        out_err_sum           = std::abs(out_err_sum);
         // Check error bias magnitude for data sets S which are not positive biased
-        TOSA_REF_REQUIRE(out_err_sum <= max_bias, "[DP] Bias magnitude (%g) is out of range (%g)", out_err_sum,
-                         max_bias);
+        TOSA_REF_REQUIRE(std::abs(out_err_sum) <= max_bias, "[DP] Bias magnitude (abs(%g)) is out of range (%g)",
+                         out_err_sum, max_bias);
     }
     // Check error variance magnitude
     const double max_error = 0.4 * KS * T;
diff --git a/reference_model/test/generate_tests.cpp b/reference_model/test/generate_tests.cpp
index 9249f55..2c318e0 100644
--- a/reference_model/test/generate_tests.cpp
+++ b/reference_model/test/generate_tests.cpp
@@ -267,7 +267,7 @@ TEST_CASE("positive - FP32 matmul dot product (first 3 values)")
     }
     SUBCASE("matmul, set 4, param 0")
     {
-        std::vector<uint32_t> expected = { 0x0, 0x3f000000, 0x5f14e80c };
+        std::vector<uint32_t> expected = { 0x0, 0xbf000000, 0x5f14e80c };
         matmul_test_FP32(tosaName, tosaElements, templateJsonCfg, "4", 0, expected);
     }
     SUBCASE("matmul, set 4, param 1")
@@ -572,7 +572,7 @@ TEST_CASE("positive - FP32 reduce_sum dot product (values 6,7 & 8)")
     }
     SUBCASE("reduce_sum, set 4, param 0")
     {
-        std::vector<uint32_t> expected = { 0x5e1e6f12, 0x3f000000, 0x3f000000 };
+        std::vector<uint32_t> expected = { 0x5e1e6f12, 0x3f000000, 0xbf000000 };
         reduce_sum_test_FP32(tosaName, tosaElements, templateJsonCfg, "4", expected);
     }
     SUBCASE("reduce_sum, set 5, param 0")
@@ -750,4 +750,77 @@ TEST_CASE("positive - FP32 fully_connected dot product (values -8, -7 & -6 from
         fully_connected_test_FP32(tosaName, tosaElements, templateJsonCfg, "5", 2, lastExpected);
     }
 }
+
+void avg_pool2d_test_FP32(const std::string tosaName,
+                          const size_t tosaElements,
+                          const std::string templateJsonCfg,
+                          const std::string setStr,
+                          const std::vector<uint32_t> expected)
+{
+    std::string jsonCfg = templateJsonCfg;
+    update_json_template(jsonCfg, "_SET_", setStr);
+
+    std::vector<float> buffer(tosaElements);
+    REQUIRE(tgd_generate_data(jsonCfg.c_str(), tosaName.c_str(), (void*)buffer.data(), tosaElements * 4));
+    std::vector<float> first_three(buffer.begin(), buffer.begin() + 3);
+    check_output<float>(first_three, expected);
+}
+
+TEST_CASE("positive - FP32 avg_pool2d dot product (first 3 values)")
+{
+    std::string templateJsonCfg = R"({
+        "tensors" : {
+            "input" : {
+                "generator": "DOT_PRODUCT",
+                "data_type": "FP32",
+                "input_type": "VARIABLE",
+                "shape" : [ 2, 6, 2, 3 ],
+                "input_pos": 0,
+                "op" : "AVG_POOL2D",
+                "dot_product_info": {
+                    "s": _SET_,
+                    "ks": 3,
+                    "acc_type": "FP32",
+                    "kernel": [3, 1]
+                }
+            }
+        }
+    })";
+
+    const std::string tosaName = "input";
+    const size_t tosaElements  = 2 * 6 * 2 * 3;
+
+    SUBCASE("avg_pool2d, set 0, param 0")
+    {
+        std::vector<uint32_t> expected = { 0xbf665aa4, 0xbf736bd3, 0x0 };
+        avg_pool2d_test_FP32(tosaName, tosaElements, templateJsonCfg, "0", expected);
+    }
+    SUBCASE("avg_pool2d, set 1, param 0")
+    {
+        // NOTE: Python test script produced 0x5e839663,0x5e9f6894 - so off by 1
+        std::vector<uint32_t> expected = { 0x5e839662, 0x5e904e86, 0x5e9f6893 };
+        avg_pool2d_test_FP32(tosaName, tosaElements, templateJsonCfg, "1", expected);
+    }
+    SUBCASE("avg_pool2d, set 2, param 0")
+    {
+        std::vector<uint32_t> expected = { 0x3f800000, 0x3e3c8d18, 0xbe813879 };
+        avg_pool2d_test_FP32(tosaName, tosaElements, templateJsonCfg, "2", expected);
+    }
+    SUBCASE("avg_pool2d, set 3, param 0")
+    {
+        // NOTE: Python test script produced 0xbf256686,0x3e1e8d3b - so off by 1
+        std::vector<uint32_t> expected = { 0x41800000, 0xbf256685, 0x3e1e8d3b };
+        avg_pool2d_test_FP32(tosaName, tosaElements, templateJsonCfg, "3", expected);
+    }
+    SUBCASE("avg_pool2d, set 4, param 0")
+    {
+        std::vector<uint32_t> expected = { 0x0, 0xbf000000, 0x5ef329c7 };
+        avg_pool2d_test_FP32(tosaName, tosaElements, templateJsonCfg, "4", expected);
+    }
+    SUBCASE("avg_pool2d, set 5, param 0")
+    {
+        std::vector<uint32_t> expected = { 0x5dd5b529, 0x5e4bbbf9, 0x5eb4fe79 };
+        avg_pool2d_test_FP32(tosaName, tosaElements, templateJsonCfg, "5", expected);
+    }
+}
 TEST_SUITE_END();    // generate
diff --git a/verif/conformance/tosa_main_profile_ops_info.json b/verif/conformance/tosa_main_profile_ops_info.json
index 6538c81..87b14c2 100644
--- a/verif/conformance/tosa_main_profile_ops_info.json
+++ b/verif/conformance/tosa_main_profile_ops_info.json
@@ -202,6 +202,7 @@
         "profile": [
             "tosa-mi"
         ],
+        "support_for": [ "lazy_data_gen" ],
         "generation": {
             "standard": {
                 "generator_args": [
@@ -213,18 +214,18 @@
                         "--target-dtype",
                         "bf16",
                         "--fp-values-range",
-                        "-2.0,2.0",
+                        "-max,max",
                         "--target-shape",
-                        "1,11,7,39",
+                        "4,11,7,39",
                         "--target-shape",
-                        "1,21,36,7",
+                        "5,21,36,7",
                         "--allow-pooling-and-conv-oversizes"
                     ],
                     [
                         "--target-dtype",
                         "fp32",
                         "--fp-values-range",
-                        "-2.0,2.0",
+                        "-max,max",
                         "--target-shape",
                         "1,2,65533,2",
                         "--target-shape",
diff --git a/verif/generator/tosa_test_gen.py b/verif/generator/tosa_test_gen.py
index a83ead0..9f65fd4 100644
--- a/verif/generator/tosa_test_gen.py
+++ b/verif/generator/tosa_test_gen.py
@@ -728,7 +728,7 @@ class TosaTestGen:
         pad = args_dict["pad"]
         kernel = args_dict["kernel"]
 
-        result_tens = OutputShaper.pool2dOp(
+        result_tensor = OutputShaper.pool2dOp(
             self.ser, self.rng, input, kernel, stride, pad, error_name
         )
 
@@ -737,12 +737,12 @@ class TosaTestGen:
             if input.dtype not in [DType.INT8, DType.UINT8]:
                 qinfo = [
                     TosaQuantGen.getZeroPoint(self, input.dtype),
-                    TosaQuantGen.getZeroPoint(self, result_tens.dtype),
+                    TosaQuantGen.getZeroPoint(self, result_tensor.dtype),
                 ]
 
         # Invalidate Input/Output list for error if checks.
         input_list = [input.name]
-        output_list = [result_tens.name]
+        output_list = [result_tensor.name]
         pCount, cCount = op["operands"]
         num_operands = pCount + cCount
         input_list, output_list = TosaErrorIfArgGen.eiInvalidateInputOutputList(
@@ -756,13 +756,13 @@ class TosaTestGen:
             op=op,
             input_shape=input.shape,
             input_dtype=input.dtype,
-            output_shape=result_tens.shape,
-            output_dtype=result_tens.dtype,
+            output_shape=result_tensor.shape,
+            output_dtype=result_tensor.dtype,
             kernel=kernel,
             stride=stride,
             pad=pad,
             qinfo=qinfo,
-            result_tensors=[result_tens],
+            result_tensors=[result_tensor],
             input_list=input_list,
             output_list=output_list,
             num_operands=num_operands,
@@ -776,25 +776,7 @@ class TosaTestGen:
         attr.PoolAttribute(kernel, stride, pad, qinfo[0], qinfo[1], accum_dtype)
 
         self.ser.addOperator(op["op"], input_list, output_list, attr)
-        return result_tens
 
-    def build_maxpool2d(
-        self,
-        op,
-        inputs,
-        args_dict,
-        validator_fcns=None,
-        error_name=None,
-        qinfo=None,
-    ):
-        result_tensor = self.build_pool2d(
-            op,
-            inputs,
-            args_dict,
-            validator_fcns,
-            error_name,
-            qinfo,
-        )
         compliance = self.tensorComplianceMetaData(
             op, inputs[0].dtype, args_dict, result_tensor, error_name
         )
@@ -3024,6 +3006,9 @@ class TosaTestGen:
                 TosaErrorValidator.evPoolingOutputShapeMismatch,
                 TosaErrorValidator.evPoolingOutputShapeNonInteger,
             ),
+            "data_gen": {
+                "fp": (gtu.DataGenType.DOT_PRODUCT,),
+            },
         },
         # Templated operator.  Filled in by createDynamicOpLists
         "conv2d_TEMPLATE": {
@@ -3173,7 +3158,7 @@ class TosaTestGen:
             "operands": (1, 0),
             "rank": (4, 4),
             "build_fcn": (
-                build_maxpool2d,
+                build_pool2d,
                 TosaTensorGen.tgNHWC,
                 TosaTensorValuesGen.tvgLazyGenDefault,
                 TosaArgGen.agPooling,