From 95a6710ffb8cadcb8658a967ab29cac1bffad930 Mon Sep 17 00:00:00 2001 From: Jeremy Johnson Date: Wed, 10 Jan 2024 14:16:39 +0000 Subject: 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 Change-Id: I8668c774e01c17e5d999aadf99c317e2dd893857 --- .../src/generate/generate_dot_product.cc | 136 ++++++++++++++++++ reference_model/src/generate/generate_utils.cc | 1 + reference_model/test/generate_tests.cpp | 159 +++++++++++++++++++++ verif/conformance/tosa_main_profile_ops_info.json | 9 +- verif/generator/tosa_arg_gen.py | 25 +++- verif/generator/tosa_error_if.py | 2 +- verif/generator/tosa_test_gen.py | 43 +++--- 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 +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(generator(k)); + } + return true; +} + +template +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(generator(k)); + } + return true; +} + +template +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(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(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(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 lastExpected) +{ + std::string jsonCfg = templateJsonCfg; + update_json_template(jsonCfg, "_SET_", setStr); + + std::vector buffer(tosaElements[param]); + REQUIRE(tgd_generate_data(jsonCfg.c_str(), tosaName[param].c_str(), (void*)buffer.data(), tosaElements[param] * 2)); + std::vector last_three(buffer.end() - std::min(3, buffer.size()), buffer.end()); + check_output(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 expected = { 0x30e3, 0x0, 0x38e7 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "0", 0, expected); + } + SUBCASE("transpose_conv2d, set 0, param 1") + { + std::vector expected = { 0x0, 0x312a, 0x0 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "0", 1, expected); + } + SUBCASE("transpose_conv2d, set 0, param 2") + { + std::vector expected = { 0x0, 0x0, 0x0 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "0", 2, expected); + } + SUBCASE("transpose_conv2d, set 1, param 0") + { + std::vector expected = { 0x4eb3, 0x4fce, 0x4e4e }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "1", 0, expected); + } + SUBCASE("transpose_conv2d, set 1, param 1") + { + std::vector expected = { 0x4e79, 0x4ed8, 0x502e }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "1", 1, expected); + } + SUBCASE("transpose_conv2d, set 1, param 2") + { + std::vector expected = { 0x6426, 0x6635, 0x680e }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "1", 2, expected); + } + SUBCASE("transpose_conv2d, set 2, param 0") + { + std::vector expected = { 0xb05d, 0xaf37, 0xa424 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "2", 0, expected); + } + SUBCASE("transpose_conv2d, set 2, param 1") + { + std::vector expected = { 0x3182, 0xacff, 0xaf9a }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "2", 1, expected); + } + SUBCASE("transpose_conv2d, set 2, param 2") + { + std::vector expected = { 0x0, 0x0, 0x0 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "2", 2, expected); + } + SUBCASE("transpose_conv2d, set 3, param 0") + { + std::vector expected = { 0xbc41, 0x1cbe, 0x3009 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "3", 0, expected); + } + SUBCASE("transpose_conv2d, set 3, param 1") + { + std::vector expected = { 0x35ac, 0x3b2a, 0x2db4 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "3", 1, expected); + } + SUBCASE("transpose_conv2d, set 3, param 2") + { + std::vector expected = { 0x0, 0x0, 0x0 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "3", 2, expected); + } + SUBCASE("transpose_conv2d, set 4, param 0") + { + std::vector expected = { 0x0, 0x0, 0x4953 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "4", 0, expected); + } + SUBCASE("transpose_conv2d, set 4, param 1") + { + std::vector expected = { 0x4e62, 0xcd17, 0x0 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "4", 1, expected); + } + SUBCASE("transpose_conv2d, set 4, param 2") + { + std::vector expected = { 0x0, 0x0, 0x0 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "4", 2, expected); + } + SUBCASE("transpose_conv2d, set 5, param 0") + { + std::vector expected = { 0x505a, 0x4ff8, 0xd174 }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "5", 0, expected); + } + SUBCASE("transpose_conv2d, set 5, param 1") + { + std::vector expected = { 0xd10e, 0xc728, 0xcd2e }; + transpose_conv2d_test_FP16(tosaName, tosaElements, templateJsonCfg, "5", 1, expected); + } + SUBCASE("transpose_conv2d, set 5, param 2") + { + std::vector 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 -- cgit v1.2.1