COMPMID-3291: Test improvement for CLWeightsReshapeKernel

Signed-off-by: Sheri Zhang <sheri.zhang@arm.com>
Change-Id: I9956a3bdfa4ddbb205111ff2524ff40cf57644e0
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/3052
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Reviewed-by: Michalis Spyrou <michalis.spyrou@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>

diff --git a/src/core/CL/kernels/CLWeightsReshapeKernel.cpp b/src/core/CL/kernels/CLWeightsReshapeKernel.cpp
index e1da4f03aec6c3768a0ddc8f56404f1aa44516c2..873f3b302272af037c064f5634a51c9a16a78f35 100644 (file)
--- a/src/core/CL/kernels/CLWeightsReshapeKernel.cpp
+++ b/src/core/CL/kernels/CLWeightsReshapeKernel.cpp
@@ -22,15 +22,8 @@
  * SOFTWARE.
  */
 #include "arm_compute/core/CL/kernels/CLWeightsReshapeKernel.h"
-
-#include "arm_compute/core/CL/CLHelpers.h"
-#include "arm_compute/core/CL/CLKernelLibrary.h"
-#include "arm_compute/core/CL/CLValidate.h"
 #include "arm_compute/core/CL/ICLTensor.h"
-#include "arm_compute/core/CL/OpenCL.h"
 #include "arm_compute/core/Error.h"
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
 #include "support/StringSupport.h"
 
@@ -43,7 +36,6 @@ namespace
 Status validate_arguments(const ITensorInfo *input, const ITensorInfo *biases, const ITensorInfo *output, unsigned int num_groups)
 {
     ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
-    ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(input);
     ARM_COMPUTE_RETURN_ERROR_ON(input->data_type() == DataType::UNKNOWN);
     ARM_COMPUTE_RETURN_ERROR_ON(num_groups == 0);
     ARM_COMPUTE_RETURN_ERROR_ON(input->data_layout() == DataLayout::NHWC && num_groups > 1);
@@ -102,7 +94,7 @@ void CLWeightsReshapeKernel::configure(const CLCompileContext &compile_context,
 
     // Create build options
     CLBuildOptions build_opts;
-    build_opts.add_option("-DDATA_TYPE=" + get_cl_type_from_data_type(data_type));
+    build_opts.add_option("-DDATA_TYPE=" + get_cl_unsigned_type_from_element_size(data_size_from_type(data_type)));
     build_opts.add_option("-DNUM_GROUPS=" + support::cpp11::to_string(num_groups));
     build_opts.add_option_if(biases != nullptr, "-DHAS_BIAS");
 

diff --git a/tests/validation/CL/WeightsReshape.cpp b/tests/validation/CL/WeightsReshape.cpp
index 47cb975527ca6d12bae7e3925a16d9564ecab063..ff7ed82d79bab6ed1bb600f24d369ac947b772a4 100644 (file)
--- a/tests/validation/CL/WeightsReshape.cpp
+++ b/tests/validation/CL/WeightsReshape.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2019 ARM Limited.
+ * Copyright (c) 2018-2020 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -23,9 +23,8 @@
  */
 #include "arm_compute/core/CL/kernels/CLWeightsReshapeKernel.h"
 #include "arm_compute/core/Types.h"
-#include "tests/CL/Helper.h"
-
 #include "tests/CL/CLAccessor.h"
+#include "tests/CL/Helper.h"
 #include "tests/datasets/ShapeDatasets.h"
 #include "tests/framework/Asserts.h"
 #include "tests/framework/Macros.h"
@@ -44,87 +43,101 @@ TEST_SUITE(WeightsReshape)
 
 using CLWeightsReshape = CLSynthetizeFunction<CLWeightsReshapeKernel>;
 
-// *INDENT-OFF*
-// clang-format off
-DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(
-               framework::dataset::make("InputInfo", { TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32),     // Mismatching data type
-                                                       TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::QASYMM8), // Bias not supported with QASYMM8
-                                                       TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32),
-                                                     }),
-               framework::dataset::make("BiasesInfo", { TensorInfo(TensorShape(4U), 1, DataType::F16),
-                                                        TensorInfo(TensorShape(4U), 1, DataType::QASYMM8),
-                                                        TensorInfo(TensorShape(4U), 1, DataType::F32),
-                                                      })),
-               framework::dataset::make("OutputInfo", { TensorInfo(TensorShape(4U, 19U), 1, DataType::F16),
-                                                        TensorInfo(TensorShape(4U, 19U), 1, DataType::QASYMM8),
-                                                        TensorInfo(TensorShape(4U, 19U), 1, DataType::F32),
-                                                      })),
-               framework::dataset::make("Expected", { false, false, true })),
-               input_info, biases_info, output_info, expected)
+/** Validate tests
+ *
+ * A series of validation tests on configurations which according to the API specification
+ * the function should fail against.
+ *
+ * Checks performed in order:
+ *     - Mismachting data type: bias need to has same data type as input
+ *     - Mismachting data type: output need to has same data type as input
+ *     - Bias only supports FP32/FP16
+ *     - num_groups != 1 is only supported for NCHW data layout
+ *     - Bias' shape need to match input's shape.
+ */
+DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(
+                                                                      framework::dataset::make("InputInfo",
+{
+    TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32),                   // Mismatching data type
+    TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32),                   // Mismatching data type
+    TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::QASYMM8),               // Bias only supports FP32/FP16
+    TensorInfo(TensorShape(3U, 3U, 2U, 4U), 1, DataType::F32, DataLayout::NHWC), // num_groups != 1 is only supported for NCHW data layout
+    TensorInfo(TensorShape(3U, 3U, 2U, 4U, 4U), 1, DataType::F32),               // Bias' shape need to match input's shape
+    TensorInfo(TensorShape(3U, 3U, 2U, 4U, 4U), 1, DataType::F32),               // Bias' shape need to match input's shape
+}),
+framework::dataset::make("BiasesInfo",
+{
+    TensorInfo(TensorShape(4U), 1, DataType::F16),
+    TensorInfo(TensorShape(4U), 1, DataType::F32),
+    TensorInfo(TensorShape(4U), 1, DataType::QASYMM8),
+    TensorInfo(TensorShape(4U), 1, DataType::F32),
+    TensorInfo(TensorShape(4U, 3U), 1, DataType::F32),
+    TensorInfo(TensorShape(3U, 4U), 1, DataType::F32),
+})),
+framework::dataset::make("OutputInfo",
+{
+    TensorInfo(TensorShape(4U, 19U), 1, DataType::F32),
+    TensorInfo(TensorShape(4U, 19U), 1, DataType::F16),
+    TensorInfo(TensorShape(4U, 19U), 1, DataType::QASYMM8),
+    TensorInfo(TensorShape(4U, 19U), 1, DataType::F32),
+    TensorInfo(TensorShape(4U, 19U), 1, DataType::F32),
+    TensorInfo(TensorShape(4U, 19U), 1, DataType::F32),
+})),
+framework::dataset::make("NumGroups", { 1, 1, 1, 2, 1, 2 })),
+framework::dataset::make("Expected", { false, false, false, false, false, false })),
+input_info, biases_info, output_info, num_groups, expected)
 {
-    bool status = bool(CLWeightsReshape::validate(&input_info, &biases_info, &output_info));
+    bool status = bool(CLWeightsReshape::validate(&input_info, &biases_info, &output_info, num_groups));
     ARM_COMPUTE_EXPECT(status == expected, framework::LogLevel::ERRORS);
 }
-// clang-format on
-// *INDENT-ON*
 
 template <typename T>
 using CLWeightsReshapeFixture = WeightsReshapeValidationFixture<CLTensor, CLAccessor, CLWeightsReshape, T>;
 
 TEST_SUITE(Float)
-TEST_SUITE(FP32)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLWeightsReshapeFixture<float>, framework::DatasetMode::ALL, combine(combine(combine(datasets::GroupedWeightsSmallShapes(), framework::dataset::make("DataType",
-                                                                                                                      DataType::F32)),
-                                                                                                              framework::dataset::make("HasBias", { true, false })),
-                                                                                                      framework::dataset::make("NumGroups", { 1, 2, 3, 4 })))
+FIXTURE_DATA_TEST_CASE(FP32, CLWeightsReshapeFixture<float>, framework::DatasetMode::ALL, combine(combine(combine(framework::dataset::make("InputShape", { TensorShape(3U, 3U, 48U, 120U) }),
+                                                                                                                  framework::dataset::make("DataType", DataType::F32)),
+                                                                                                          framework::dataset::make("HasBias", { true, false })),
+                                                                                                  framework::dataset::make("NumGroups", { 1, 2 })))
 {
     // Validate output
     validate(CLAccessor(_target), _reference);
 }
-FIXTURE_DATA_TEST_CASE(RunLarge, CLWeightsReshapeFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::GroupedWeightsLargeShapes(), framework::dataset::make("DataType",
-                                                                                                                  DataType::F32)),
-                                                                                                                  framework::dataset::make("HasBias", { true, false })),
-                                                                                                          framework::dataset::make("NumGroups", { 1, 2, 3, 4 })))
-{
-    // Validate output
-    validate(CLAccessor(_target), _reference);
-}
-TEST_SUITE_END()
 
-TEST_SUITE(FP16)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLWeightsReshapeFixture<half>, framework::DatasetMode::ALL, combine(combine(combine(datasets::GroupedWeightsSmallShapes(), framework::dataset::make("DataType",
-                                                                                                                     DataType::F16)),
-                                                                                                             framework::dataset::make("HasBias", { true, false })),
-                                                                                                     framework::dataset::make("NumGroups", { 1, 2, 3 })))
+FIXTURE_DATA_TEST_CASE(FP16, CLWeightsReshapeFixture<half>, framework::DatasetMode::ALL, combine(combine(combine(framework::dataset::make("InputShape", { TensorShape(13U, 13U, 96U, 240U) }),
+                                                                                                                 framework::dataset::make("DataType", DataType::F16)),
+                                                                                                         framework::dataset::make("HasBias", { true, false })),
+                                                                                                 framework::dataset::make("NumGroups", { 3, 4 })))
 {
     // Validate output
     validate(CLAccessor(_target), _reference);
 }
-FIXTURE_DATA_TEST_CASE(RunLarge, CLWeightsReshapeFixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::GroupedWeightsLargeShapes(), framework::dataset::make("DataType",
-                                                                                                                 DataType::F16)),
-                                                                                                                 framework::dataset::make("HasBias", { true, false })),
-                                                                                                         framework::dataset::make("NumGroups", { 1, 2, 3 })))
+
+FIXTURE_DATA_TEST_CASE(BFloat16, CLWeightsReshapeFixture<half>, framework::DatasetMode::ALL, combine(combine(combine(framework::dataset::make("InputShape", { TensorShape(9U, 9U, 96U, 240U) }),
+                                                                                                                     framework::dataset::make("DataType", DataType::BFLOAT16)),
+                                                                                                             framework::dataset::make("HasBias", { false })),
+                                                                                                     framework::dataset::make("NumGroups", { 3, 4 })))
 {
     // Validate output
     validate(CLAccessor(_target), _reference);
 }
-TEST_SUITE_END()
 
 TEST_SUITE_END()
 
-TEST_SUITE(QASYMM8)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLWeightsReshapeFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(datasets::GroupedWeightsSmallShapes(), framework::dataset::make("DataType",
-                                                                                                                        DataType::QASYMM8)),
-                                                                                                                framework::dataset::make("HasBias", { false })),
-                                                                                                        framework::dataset::make("NumGroups", { 1, 2, 3 })))
+TEST_SUITE(Quantized)
+FIXTURE_DATA_TEST_CASE(QASYMM8, CLWeightsReshapeFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(framework::dataset::make("InputShape", { TensorShape(5U, 5U, 48U, 120U) }),
+                                                                                                                       framework::dataset::make("DataType", DataType::QASYMM8)),
+                                                                                                               framework::dataset::make("HasBias", { false })),
+                                                                                                       framework::dataset::make("NumGroups", { 1, 2 })))
 {
     // Validate output
     validate(CLAccessor(_target), _reference);
 }
-FIXTURE_DATA_TEST_CASE(RunLarge, CLWeightsReshapeFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::GroupedWeightsLargeShapes(), framework::dataset::make("DataType",
-                                                                                                                    DataType::QASYMM8)),
-                                                                                                                    framework::dataset::make("HasBias", { false })),
-                                                                                                            framework::dataset::make("NumGroups", { 1, 2, 3 })))
+
+FIXTURE_DATA_TEST_CASE(QASYMM8_SIGNED, CLWeightsReshapeFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(framework::dataset::make("InputShape", { TensorShape(5U, 5U, 48U, 120U) }),
+                                                                                                                      framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
+                                                                                                                      framework::dataset::make("HasBias", { false })),
+                                                                                                              framework::dataset::make("NumGroups", { 1, 2 })))
 {
     // Validate output
     validate(CLAccessor(_target), _reference);