Main Compliance: TRANSPOSE_CONV2D support

Update data generator for main compliance values.
Add test generation support.
Fixed test set by including large 65k tests that were missing.

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

7 files changed, 353 insertions, 22 deletions

diff --git a/reference_model/src/generate/generate_dot_product.cc b/reference_model/src/generate/generate_dot_product.cc
index a5870c9..fe829e3 100644
--- a/reference_model/src/generate/generate_dot_product.cc
+++ b/reference_model/src/generate/generate_dot_product.cc
@@ -602,6 +602,140 @@ bool generateDepthwiseConv2D(const TosaReference::GenerateConfig& cfg,
             return false;
     }
 }
+//---------------------------------------------------------------------------//
+//                              Transpose Conv2D                             //
+//---------------------------------------------------------------------------//
+
+template <typename DataType>
+bool generateTransposeConv2DInput(const TosaReference::GenerateConfig& cfg,
+                                  TosaReference::IDotProductGenerator& generator,
+                                  DataType* data,
+                                  size_t size)
+{
+    if (cfg.dotProductInfo.kernel.size() != 2 || cfg.dotProductInfo.kernel[0] <= 0 || cfg.dotProductInfo.kernel[1] <= 0)
+    {
+        WARNING("[Generator][DP][TConv2D][Input] Missing or incorrect kernel size information.");
+        return false;
+    }
+    if (cfg.shape.size() != 4)
+    {
+        WARNING("[Generator][DP][TConv2D][Input] Tensor shape expected 4 dimensions.");
+        return false;
+    }
+
+    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 IC = cfg.shape[3];
+    const uint32_t KH = cfg.dotProductInfo.kernel[0];
+    const uint32_t KW = cfg.dotProductInfo.kernel[1];
+
+    for (int64_t t = 0; t < T; ++t)
+    {
+        uint32_t ic = t % IC;
+        uint32_t ix = (t / IC) % IW;
+        uint32_t iy = ((t / IC) / IW) % IH;
+        uint32_t k  = ((iy % KH) * KW + (ix % KW)) * IC + ic;
+
+        data[t] = static_cast<DataType>(generator(k));
+    }
+    return true;
+}
+
+template <typename DataType>
+bool generateTransposeConv2DWeight(const TosaReference::GenerateConfig& cfg,
+                                   TosaReference::IDotProductGenerator& generator,
+                                   DataType* data,
+                                   size_t size)
+{
+    if (cfg.shape.size() != 4)
+    {
+        WARNING("[Generator][DP][TConv2D][Weight] Tensor shape expected 4 dimensions.");
+        return false;
+    }
+
+    const int64_t T   = TosaReference::numElementsFromShape(cfg.shape);
+    const uint32_t KH = cfg.shape[1];
+    const uint32_t KW = cfg.shape[2];
+    const uint32_t IC = cfg.shape[3];
+
+    for (int64_t t = 0; t < T; ++t)
+    {
+        uint32_t ic = t % IC;
+        uint32_t kx = (t / IC) % KW;
+        uint32_t ky = ((t / IC) / KW) % KH;
+        uint32_t k  = (ky * KW + kx) * IC + ic;
+
+        data[t] = static_cast<DataType>(generator(k));
+    }
+    return true;
+}
+
+template <typename DataType>
+bool generateTransposeConv2DBias(const TosaReference::GenerateConfig& cfg,
+                                 TosaReference::IDotProductGenerator& generator,
+                                 DataType* data,
+                                 size_t size)
+{
+    if (cfg.shape.size() != 1)
+    {
+        WARNING("[Generator][DP][TConv2D][Bias] Tensor shape expected 1 dimension.");
+        return false;
+    }
+
+    const uint32_t T = cfg.shape[0];
+
+    for (uint32_t t = 0; t < T; ++t)
+    {
+        data[t] = static_cast<DataType>(generator(2));
+    }
+    return true;
+}
+
+bool generateTransposeConv2D(const TosaReference::GenerateConfig& cfg,
+                             TosaReference::IDotProductGenerator& generator,
+                             void* data,
+                             size_t size)
+{
+    switch (cfg.dataType)
+    {
+        case DType::DType_FP32: {
+            float* outData = reinterpret_cast<float*>(data);
+            switch (cfg.inputPos)
+            {
+                case 0:
+                    return generateTransposeConv2DInput(cfg, generator, outData, size);
+                case 1:
+                    return generateTransposeConv2DWeight(cfg, generator, outData, size);
+                case 2:
+                    return generateTransposeConv2DBias(cfg, generator, outData, size);
+                default:
+                    WARNING("[Generator][DP][TConv2D] Invalid input tensor slot position to operator.");
+                    return false;
+            }
+            break;
+        }
+        case DType::DType_FP16: {
+            half_float::half* outData = reinterpret_cast<half_float::half*>(data);
+            switch (cfg.inputPos)
+            {
+                case 0:
+                    return generateTransposeConv2DInput(cfg, generator, outData, size);
+                case 1:
+                    return generateTransposeConv2DWeight(cfg, generator, outData, size);
+                case 2:
+                    return generateTransposeConv2DBias(cfg, generator, outData, size);
+                default:
+                    WARNING("[Generator][DP][TConv2D] Invalid input tensor slot position to operator.");
+                    return false;
+            }
+            break;
+        }
+        default:
+            WARNING("[Generator][DP][TConv2D] Only supports FP32 or FP16.");
+            return false;
+    }
+}
 }    // namespace
 
 namespace TosaReference
@@ -636,6 +770,8 @@ bool generateDotProduct(const GenerateConfig& cfg, void* data, size_t size)
             return generateAvgPool2D(cfg, *generator, data, size);
         case tosa::Op_DEPTHWISE_CONV2D:
             return generateDepthwiseConv2D(cfg, *generator, data, size);
+        case tosa::Op_TRANSPOSE_CONV2D:
+            return generateTransposeConv2D(cfg, *generator, data, size);
         default:
             WARNING("[Generator][DP] Unsupported operator.");
             return false;
diff --git a/reference_model/src/generate/generate_utils.cc b/reference_model/src/generate/generate_utils.cc
index b2208c7..9807336 100644
--- a/reference_model/src/generate/generate_utils.cc
+++ b/reference_model/src/generate/generate_utils.cc
@@ -81,6 +81,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(Op,
                                  { Op::Op_SUB, "SUB" },
                                  { Op::Op_TANH, "TANH" },
                                  { Op::Op_TILE, "TILE" },
+                                 { Op::Op_TRANSPOSE_CONV2D, "TRANSPOSE_CONV2D" },
                              })
 
 }    // namespace tosa
diff --git a/reference_model/test/generate_tests.cpp b/reference_model/test/generate_tests.cpp
index c01a223..c45c5b6 100644
--- a/reference_model/test/generate_tests.cpp
+++ b/reference_model/test/generate_tests.cpp
@@ -1065,4 +1065,163 @@ TEST_CASE("positive - FP16 depthwise_conv2d dot product (first 3 values)")
     }
 }
 
+void transpose_conv2d_test_FP16(const std::string tosaName[3],
+                                const size_t tosaElements[3],
+                                const std::string templateJsonCfg,
+                                const std::string setStr,
+                                int32_t param,
+                                const std::vector<uint16_t> lastExpected)
+{
+    std::string jsonCfg = templateJsonCfg;
+    update_json_template(jsonCfg, "_SET_", setStr);
+
+    std::vector<half_float::half> buffer(tosaElements[param]);
+    REQUIRE(tgd_generate_data(jsonCfg.c_str(), tosaName[param].c_str(), (void*)buffer.data(), tosaElements[param] * 2));
+    std::vector<half_float::half> last_three(buffer.end() - std::min<int>(3, buffer.size()), buffer.end());
+    check_output<half_float::half>(last_three, lastExpected);
+}
+
+TEST_CASE("positive - FP16 transpose_conv2d dot product (last 3 values)")
+{
+    std::string templateJsonCfg = R"({
+        "tensors" : {
+            "input" : {
+                "generator": "DOT_PRODUCT",
+                "data_type": "FP16",
+                "input_type": "VARIABLE",
+                "shape" : [1, 5, 6, 3],
+                "input_pos": 0,
+                "op" : "TRANSPOSE_CONV2D",
+                "dot_product_info": {
+                    "s": _SET_,
+                    "ks": 30,
+                    "acc_type": "FP16",
+                    "kernel": [5, 2]
+                }
+            },
+            "weight" : {
+                "generator": "DOT_PRODUCT",
+                "data_type": "FP16",
+                "input_type": "CONSTANT",
+                "shape" : [3, 5, 2, 3],
+                "input_pos": 1,
+                "op" : "TRANSPOSE_CONV2D",
+                "dot_product_info": {
+                    "s": _SET_,
+                    "ks": 30,
+                    "acc_type": "FP16"
+                }
+            },
+            "bias" : {
+                "generator": "DOT_PRODUCT",
+                "data_type": "FP16",
+                "input_type": "CONSTANT",
+                "shape" : [3],
+                "input_pos": 2,
+                "op" : "TRANSPOSE_CONV2D",
+                "dot_product_info": {
+                    "s": _SET_,
+                    "ks": 30,
+                    "acc_type": "FP16"
+                }
+            }
+
+        }
+    })";
+
+    const std::string tosaName[3] = { "input", "weight", "bias" };
+    const size_t tosaElements[3]  = { (1 * 5 * 6 * 3), (3 * 5 * 2 * 3), 3 };
+
+    SUBCASE("transpose_conv2d, set 0, param 0")
+    {
+        std::vector<uint16_t> expected = { 0x30e3, 0x0, 0x38e7 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "0", 0, expected);
+    }
+    SUBCASE("transpose_conv2d, set 0, param 1")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x312a, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "0", 1, expected);
+    }
+    SUBCASE("transpose_conv2d, set 0, param 2")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x0, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "0", 2, expected);
+    }
+    SUBCASE("transpose_conv2d, set 1, param 0")
+    {
+        std::vector<uint16_t> expected = { 0x4eb3, 0x4fce, 0x4e4e };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "1", 0, expected);
+    }
+    SUBCASE("transpose_conv2d, set 1, param 1")
+    {
+        std::vector<uint16_t> expected = { 0x4e79, 0x4ed8, 0x502e };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "1", 1, expected);
+    }
+    SUBCASE("transpose_conv2d, set 1, param 2")
+    {
+        std::vector<uint16_t> expected = { 0x6426, 0x6635, 0x680e };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "1", 2, expected);
+    }
+    SUBCASE("transpose_conv2d, set 2, param 0")
+    {
+        std::vector<uint16_t> expected = { 0xb05d, 0xaf37, 0xa424 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "2", 0, expected);
+    }
+    SUBCASE("transpose_conv2d, set 2, param 1")
+    {
+        std::vector<uint16_t> expected = { 0x3182, 0xacff, 0xaf9a };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "2", 1, expected);
+    }
+    SUBCASE("transpose_conv2d, set 2, param 2")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x0, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "2", 2, expected);
+    }
+    SUBCASE("transpose_conv2d, set 3, param 0")
+    {
+        std::vector<uint16_t> expected = { 0xbc41, 0x1cbe, 0x3009 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "3", 0, expected);
+    }
+    SUBCASE("transpose_conv2d, set 3, param 1")
+    {
+        std::vector<uint16_t> expected = { 0x35ac, 0x3b2a, 0x2db4 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "3", 1, expected);
+    }
+    SUBCASE("transpose_conv2d, set 3, param 2")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x0, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "3", 2, expected);
+    }
+    SUBCASE("transpose_conv2d, set 4, param 0")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x0, 0x4953 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "4", 0, expected);
+    }
+    SUBCASE("transpose_conv2d, set 4, param 1")
+    {
+        std::vector<uint16_t> expected = { 0x4e62, 0xcd17, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "4", 1, expected);
+    }
+    SUBCASE("transpose_conv2d, set 4, param 2")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x0, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "4", 2, expected);
+    }
+    SUBCASE("transpose_conv2d, set 5, param 0")
+    {
+        std::vector<uint16_t> expected = { 0x505a, 0x4ff8, 0xd174 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "5", 0, expected);
+    }
+    SUBCASE("transpose_conv2d, set 5, param 1")
+    {
+        std::vector<uint16_t> expected = { 0xd10e, 0xc728, 0xcd2e };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "5", 1, expected);
+    }
+    SUBCASE("transpose_conv2d, set 5, param 2")
+    {
+        std::vector<uint16_t> expected = { 0x0, 0x0, 0x0 };
+        transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "5", 2, 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 c77f0be..266af4d 100644
--- a/verif/conformance/tosa_main_profile_ops_info.json
+++ b/verif/conformance/tosa_main_profile_ops_info.json
@@ -2174,6 +2174,7 @@
         "profile": [
             "tosa-mi"
         ],
+        "support_for": [ "lazy_data_gen" ],
         "generation": {
             "standard": {
                 "negative_dim_range": "1,10",
@@ -2186,7 +2187,7 @@
                         "--target-dtype",
                         "bf16",
                         "--fp-values-range",
-                        "-2.0,2.0",
+                        "-max,max",
                         "--target-shape",
                         "10,24,9,13",
                         "--target-shape",
@@ -2197,11 +2198,11 @@
                     ],
                     [
                         "--target-dtype",
-                        "fp16",
+                        "fp32",
                         "--fp-values-range",
-                        "-2.0,2.0",
+                        "-max,max",
                         "--target-shape",
-                        "1,65536,1",
+                        "1,65536,1,2",
                         "--tensor-dim-range",
                         "1,17",
                         "--max-conv-dilation",
diff --git a/verif/generator/tosa_arg_gen.py b/verif/generator/tosa_arg_gen.py
index 8501caa..91d2d62 100644
--- a/verif/generator/tosa_arg_gen.py
+++ b/verif/generator/tosa_arg_gen.py
@@ -2186,6 +2186,8 @@ class TosaArgGen:
             assert len(filter_shape) == 4
 
         k_shape = tuple(filter_shape[1:3])
+        # compliance size - KS
+        k_size = gtu.product((*k_shape, ifm_shape[3]))
 
         if not testGen.args.level8k:
             # Generate comprehensive argument lists
@@ -2283,6 +2285,19 @@ class TosaArgGen:
                     ow = (ifm_shape[2] - 1) * s[1] + p[2] + p[3] + k_shape[1]
                     os = [ifm_shape[0], oh, ow, filter_shape[0]]
 
+                    # N*OH*OW*OC
+                    dots = gtu.product((ifm_shape[0], oh, ow, filter_shape[0]))
+                    args_dict = {
+                        "acc_type": accum_dtype,
+                        "stride": s,
+                        "pad": p,
+                        "kernel": k_shape,
+                        "ks": k_size,
+                        "dot_products": dots,
+                        "shape": ifm_shape,
+                        "out_shape": os,
+                    }
+
                     # Support for larger values than 9 needs different delimiter
                     delim = "" if max(s + p) <= 9 else "x"
                     arg_list.append(
@@ -2293,11 +2308,19 @@ class TosaArgGen:
                                 delim.join([str(x) for x in p]),
                                 "x".join([str(x) for x in os]),
                             ),
-                            [accum_dtype, s, p, os],
+                            args_dict,
                         )
                     )
                 n += 1
 
+        arg_list = TosaArgGen._add_data_generators(
+            testGen,
+            opName,
+            dtypes[0],
+            arg_list,
+            error_name,
+        )
+        # Return list of tuples: (arg_str, args_dict)
         return arg_list
 
     @staticmethod
diff --git a/verif/generator/tosa_error_if.py b/verif/generator/tosa_error_if.py
index 5874123..a5a834f 100644
--- a/verif/generator/tosa_error_if.py
+++ b/verif/generator/tosa_error_if.py
@@ -2701,7 +2701,7 @@ class TosaInvalidValidator:
     @staticmethod
     def ivNonPositiveOutputShape(**kwargs):
         args = kwargs["args"]
-        output_shape = args[3]
+        output_shape = args["out_shape"]
         if output_shape[1] <= 0 or output_shape[2] <= 0:
             # Negative output shape
             return True
diff --git a/verif/generator/tosa_test_gen.py b/verif/generator/tosa_test_gen.py
index 6867979..39b064d 100644
--- a/verif/generator/tosa_test_gen.py
+++ b/verif/generator/tosa_test_gen.py
@@ -324,6 +324,7 @@ class TosaTestGen:
             Op.CONV2D,
             Op.FULLY_CONNECTED,
             Op.DEPTHWISE_CONV2D,
+            Op.TRANSPOSE_CONV2D,
         )
         if (
             errorName
@@ -987,19 +988,21 @@ class TosaTestGen:
     def build_transpose_conv2d(
         self,
         op,
-        ifm,
-        filter,
-        bias,
-        accum_dtype,
-        stride,
-        out_pad,
-        output_shape,
+        inputs,
+        args_dict,
         validator_fcns=None,
         error_name=None,
         qinfo=None,
     ):
+        assert len(inputs) == 3
+        ifm, filter, bias = inputs
+        accum_dtype = args_dict["acc_type"]
+        strides = args_dict["stride"]
+        out_pad = args_dict["pad"]
+        output_shape = args_dict["out_shape"]
+
         assert len(out_pad) == 4
-        result_tens = OutputShaper.transposeConv2DOp(
+        result_tensor = OutputShaper.transposeConv2DOp(
             self.ser, self.rng, ifm, output_shape, accum_dtype, error_name
         )
 
@@ -1010,12 +1013,12 @@ class TosaTestGen:
         ):
             qinfo = [
                 TosaQuantGen.getZeroPoint(self, ifm.dtype),
-                TosaQuantGen.getZeroPoint(self, result_tens.dtype),
+                TosaQuantGen.getZeroPoint(self, result_tensor.dtype),
             ]
 
         # Invalidate Input/Output list for error_if checks.
         input_list = [ifm.name, filter.name, bias.name]
-        output_list = [result_tens.name]
+        output_list = [result_tensor.name]
         num_operands = sum(op["operands"])
         input_list, output_list = TosaErrorIfArgGen.eiInvalidateInputOutputList(
             self, error_name, input_list, output_list
@@ -1028,16 +1031,16 @@ class TosaTestGen:
             op=op,
             input_dtype=ifm.dtype,
             weight_dtype=filter.dtype,
-            output_dtype=result_tens.dtype,
+            output_dtype=result_tensor.dtype,
             qinfo=qinfo,
             input_list=input_list,
             num_operands=num_operands,
             output_list=output_list,
             pad=out_pad,
-            stride=stride,
+            stride=strides,
             input_shape=ifm.shape,
             weight_shape=filter.shape,
-            output_shape=result_tens.shape,
+            output_shape=result_tensor.shape,
         ):
             return None
 
@@ -1046,11 +1049,16 @@ class TosaTestGen:
 
         attr = ts.TosaSerializerAttribute()
         attr.TransposeConvAttribute(
-            out_pad, stride, output_shape, qinfo[0], qinfo[1], local_bound
+            out_pad, strides, output_shape, qinfo[0], qinfo[1], local_bound
         )
 
         self.ser.addOperator(op["op"], input_list, output_list, attr)
-        return result_tens
+
+        compliance = self.tensorComplianceMetaData(
+            op, ifm.dtype, args_dict, result_tensor, error_name
+        )
+
+        return TosaTestGen.BuildInfo(result_tensor, compliance)
 
     def build_depthwise_conv2d(
         self,
@@ -3307,7 +3315,7 @@ class TosaTestGen:
             "build_fcn": (
                 build_transpose_conv2d,
                 TosaTensorGen.tgTransposeConv2D,
-                TosaTensorValuesGen.tvgDefault,
+                TosaTensorValuesGen.tvgLazyGenDefault,
                 TosaArgGen.agTransposeConv2D,
             ),
             "qgen": TosaQuantGen.qgConv,
@@ -3328,6 +3336,9 @@ class TosaTestGen:
                 TosaErrorValidator.evWrongRank,
                 TosaErrorValidator.evConvOutputShapeMismatch,
             ),
+            "data_gen": {
+                "fp": (gtu.DataGenType.DOT_PRODUCT,),
+            },
             "template": True,
         },
         # Activation functions