feat: enable F32 output in CpuGemmConv2d

- Updated convolution reference to branch epilogue:
  * TO=float: int32 to float dequant (acc * sA * sB + bias_f32)
  * TO!=float: usual quantize_down_scale_by_fixedpoint with int32 bias
- Changed fixture to use F32 bias tensor for Q->F32 runs (instead of S32),
  matching arm_gemm dequant epilogue which only supports float bias.
- Added explicit template instantiations for convolution_layer with
  TBias=float, TO=float to fix linker errors in validation.
- Disabled activation in arm_gemm dequant path:
  offsets are applied afterwards by CpuGemmLowpOffsetContributionKernel,
  so activation must run there to see the correct final accumulator.

This aligns target and reference for quantized to F32 convolution tests
and prevents premature clamping before offset contributions.

Change-Id: I6fffc98dc0798542a2702e6a593b850c16561e3b
Signed-off-by: Pablo Marquez Tello <[email protected]>

Author: morgolock

src/cpu/operators/CpuGemmConv2d.cpp

@@ -287,12 +287,29 @@ void CpuGemmConv2d::configure_mm(const ITensorInfo         *src,
         }
 
         GEMMLowpOutputStageInfo output_info;
-        output_info.type                     = GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT;
-        output_info.gemmlowp_offset          = uoqinfo.offset;
-        output_info.gemmlowp_min_bound       = min_activation;
-        output_info.gemmlowp_max_bound       = max_activation;
-        output_info.is_quantized_per_channel = (tmp_weights.data_type() == DataType::QSYMM8_PER_CHANNEL);
-        quantization::calculate_quantized_multipliers(iqinfo, wqinfo, oqinfo, output_info);
+
+        // F32 dequant path? (input quantized, output float)
+        const bool dequantize_f32 = (dst->data_type() == DataType::F32);
+
+        if (dequantize_f32)
+        {
+            // No requant stage; offsets are handled via offset-contribution on int32
+            output_info.type                     = GEMMLowpOutputStageType::NONE;
+            output_info.gemmlowp_offset          = 0;
+            output_info.gemmlowp_min_bound       = 0;
+            output_info.gemmlowp_max_bound       = 0;
+            output_info.is_quantized_per_channel = false; // irrelevant when NONE
+        }
+        else
+        {
+            // Existing Q->Q path
+            output_info.type                     = GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT;
+            output_info.gemmlowp_offset          = uoqinfo.offset;
+            output_info.gemmlowp_min_bound       = min_activation;
+            output_info.gemmlowp_max_bound       = max_activation;
+            output_info.is_quantized_per_channel = (tmp_weights.data_type() == DataType::QSYMM8_PER_CHANNEL);
+            quantization::calculate_quantized_multipliers(iqinfo, wqinfo, oqinfo, output_info);
+        }
 
         const GEMMInfo gemm_info =
             GEMMInfo(false /* is_a_reshaped */, false /* is_b_reshaped */, true /* reshape_b_only_on_first_run */,
@@ -504,9 +521,11 @@ void CpuGemmConv2d::configure(const ITensorInfo         *src,
     }
 
     const unsigned int mat_weights_cols = weights->dimension(idx_kernels);
+    const bool         dequantize_f32   = is_data_type_quantized(data_type) && dst->data_type() == DataType::F32;
 
     // Create temporary GEMM output tensor in case we cannot skip col2im
-    const DataType output_data_type = data_type == DataType::BFLOAT16 ? DataType::F32 : data_type;
+    const DataType output_data_type = data_type == DataType::BFLOAT16 || dequantize_f32 ? DataType::F32 : data_type;
+
     if (!_skip_col2im)
     {
         TensorShape shape_gemm;
@@ -725,7 +744,14 @@ Status CpuGemmConv2d::validate(const ITensorInfo         *src,
     {
         if (is_quantized)
         {
-            ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(biases, 1, DataType::S32);
+            if (data_type == DataType::QASYMM8_SIGNED && dst->data_type() == DataType::F32)
+            {
+                ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(biases, 1, DataType::F32);
+            }
+            else
+            {
+                ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(biases, 1, DataType::S32);
+            }
         }
         else if (is_bf16)
         {
@@ -776,8 +802,9 @@ Status CpuGemmConv2d::validate(const ITensorInfo         *src,
         gemm_input_to_use = &im2col_reshaped_info;
     }
 
+    const bool dequantize_f32 = is_data_type_quantized(data_type) && dst->data_type() == DataType::F32;
     // Create temporary GEMM output tensor in case we cannot skip col2im
-    const DataType output_data_type = data_type == DataType::BFLOAT16 ? DataType::F32 : data_type;
+    const DataType output_data_type = data_type == DataType::BFLOAT16 || dequantize_f32 ? DataType::F32 : data_type;
     if (!skip_col2im)
     {
         TensorShape shape_gemm = gemm_input_to_use->tensor_shape();

src/cpu/operators/CpuGemmLowpMatrixMultiplyCore.cpp

@@ -200,7 +200,7 @@ void CpuGemmLowpMatrixMultiplyCore::configure(
             case DataType::U8:
             case DataType::S8:
             {
-                if (is_data_type_quantized_asymmetric(a_to_use->data_type()) &&
+                if (dst->data_type() != DataType::F32 && is_data_type_quantized_asymmetric(a_to_use->data_type()) &&
                     info.gemmlowp_output_stage().type == GEMMLowpOutputStageType::QUANTIZE_DOWN_FIXEDPOINT)
                 {
                     auto c_info_to_use = c == nullptr ? nullptr : c;

tests/datasets/SmallConvolutionLayerDataset.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Arm Limited.
+ * Copyright (c) 2017-2021, 2025 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -21,8 +21,8 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#ifndef ARM_COMPUTE_TEST_SMALL_CONVOLUTION_LAYER_DATASET
-#define ARM_COMPUTE_TEST_SMALL_CONVOLUTION_LAYER_DATASET
+#ifndef ACL_TESTS_DATASETS_SMALLCONVOLUTIONLAYERDATASET_H
+#define ACL_TESTS_DATASETS_SMALLCONVOLUTIONLAYERDATASET_H
 
 #include "tests/datasets/ConvolutionLayerDataset.h"
 
@@ -246,4 +246,4 @@ class SmallGroupedConvolutionLayerDataset final : public ConvolutionLayerDataset
 } // namespace datasets
 } // namespace test
 } // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_SMALL_CONVOLUTION_LAYER_DATASET */
+#endif // ACL_TESTS_DATASETS_SMALLCONVOLUTIONLAYERDATASET_H

tests/validation/NEON/ConvolutionLayer.cpp

@@ -1363,6 +1363,10 @@ template <typename T>
 using NEGEMMConvolutionLayerForUpdatedStaticQuantInfoAfterConfigureFixture = ConvolutionValidationForUpdatedStaticQuantInfoAfterConfigureFixture<Tensor, Accessor, NEGEMMConvolutionLayer, T>;
 template <typename T>
 using NEGEMMConvolutionLayerQuantizedFixture = ConvolutionValidationQuantizedFixture<Tensor, Accessor, NEConvolutionLayer, T>;
+template <typename T>
+using NEGEMMConvolutionLayerQuantizedF32OutputFixture = ConvolutionValidationQuantizedFixture<Tensor, Accessor, NEConvolutionLayer, T,false,float>;
+
+
 template <typename T>
 using NEGEMMConvolutionLayerQuantizedMixedDataLayoutFixture = ConvolutionValidationQuantizedFixture<Tensor, Accessor, NEConvolutionLayer, T, true>;
 
@@ -1397,6 +1401,21 @@ FIXTURE_DATA_TEST_CASE(RunSmall, NEGEMMConvolutionLayerForUpdatedStaticQuantInfo
     // Validate output
     validate(Accessor(_target), _reference, tolerance_qasymm8);
 }
+
+FIXTURE_DATA_TEST_CASE(RunSmallDequantizeF32, NEGEMMConvolutionLayerQuantizedF32OutputFixture<int8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::SmallConvolutionLayerDataset(),
+                                                                                                                       framework::dataset::make("ReshapeWeights", { true })),
+                                                                                                                       framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
+                                                                                                                       framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
+                                                            framework::dataset::make("QuantizationInfoIfActivationEnabled", { QuantizationInfo(2.f / 255.f, 10) })),
+                                                            framework::dataset::make("ActivationInfo", {ActivationLayerInfo()})))
+{
+    // Validate output
+    validate(Accessor(_target), _reference, rel_tolerance_f32, 0.f, float(abs_tolerance_f32));
+}
+
+
+
+
 TEST_SUITE_END() // QASYMM8_SIGNED
 
 TEST_SUITE(QASYMM8)
@@ -1425,6 +1444,7 @@ FIXTURE_DATA_TEST_CASE(RunSmall, NEGEMMConvolutionLayerQuantizedFixture<uint8_t>
     // Validate output
     validate(Accessor(_target), _reference, tolerance_qasymm8);
 }
+
 FIXTURE_DATA_TEST_CASE(RunMixedDataLayout, NEGEMMConvolutionLayerQuantizedFixture<uint8_t>, framework::DatasetMode::ALL,
                        combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(
                                                                                                    framework::dataset::make("Input", TensorShape(23U, 27U, 5U)),

tests/validation/fixtures/ConvolutionLayerFixture.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2024 Arm Limited.
+ * Copyright (c) 2017-2025 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -46,7 +46,7 @@
 #include "tests/validation/reference/PadLayer.h"
 #include "tests/validation/reference/Permute.h"
 #include "tests/validation/reference/Utils.h"
-
+#include "tests/validation/reference/DequantizationLayer.h"
 #include <random>
 #include <type_traits>
 
@@ -85,13 +85,28 @@ configure_conv_function(ConvolutionFunction &func,
 #endif // ARM_COMPUTE_OPENCL_ENABLED
 } // namespace detail
 
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename TW>
+template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename TW, typename TO=T>
 class ConvolutionValidationGenericFixture : public framework::Fixture
 {
 public:
-    using TBias = typename std::conditional < std::is_same<typename std::decay<T>::type, uint8_t>::value
-                  || std::is_same<typename std::decay<T>::type, int8_t>::value,
-                  int32_t, T >::type;
+    // Quantized input?
+    static constexpr bool T_is_q =
+        std::is_same<typename std::decay<T>::type, uint8_t>::value ||
+        std::is_same<typename std::decay<T>::type, int8_t>::value;
+
+    // Float output?
+    static constexpr bool TO_is_f32 =
+        std::is_same<typename std::decay<TO>::type, float>::value;
+
+    // Bias type:
+    //  - Q->F32: float
+    //  - Q->Q  : int32_t
+    //  - FP->* : T
+    using TBias = typename std::conditional<
+        (T_is_q && TO_is_f32),
+        float,
+        typename std::conditional<T_is_q, int32_t, T>::type
+    >::type;
 
     void setup_quantization(TensorShape input_shape, TensorShape weights_shape, QuantizationInfo &input_q_info,
         QuantizationInfo &weights_q_info, DataType data_type)
@@ -144,14 +159,21 @@ class ConvolutionValidationGenericFixture : public framework::Fixture
         _data_type                = data_type;
         _weights_data_type        = weights_data_type;
         const bool is_quantized   = is_data_type_quantized(weights_data_type);
-        _is_bfloat16              = data_type == DataType::BFLOAT16;
-        _bias_data_type           = is_quantized ? DataType::S32 : (_is_bfloat16 ? DataType::F32 : data_type);
-        _output_data_type         = _is_bfloat16 ? DataType::F32 : data_type;
+
+        _is_bfloat16            = data_type == DataType::BFLOAT16;
+        _output_data_type       = (_is_bfloat16 || std::is_same<TO, float>::value) ? DataType::F32 : data_type;
+
+        const bool q_to_f32     = is_quantized && (_output_data_type == DataType::F32);
+        _bias_data_type         = q_to_f32 ? DataType::F32
+                                   : (is_quantized ? DataType::S32
+                                                   : (_is_bfloat16 ? DataType::F32 : data_type));
+
         _quantization_info        = quantization_info;
         _weight_quantization_info = weight_quantization_info;
         _data_layout              = data_layout;
         _dst_q_info               = quantization_info;
 
+
         if(is_quantized && !is_data_type_quantized_symmetric(weights_data_type) && (!act_info.enabled() || act_info.activation() == ActivationFunction::IDENTITY))
         {
             setup_quantization(input_shape, weights_shape, _quantization_info, _weight_quantization_info, data_type);
@@ -503,11 +525,10 @@ class ConvolutionValidationGenericFixture : public framework::Fixture
             // Compute Convolution function
             conv.run();
         }
-
         return dst;
     }
 
-    SimpleTensor<T> compute_reference(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, const PadStrideInfo &info,
+    SimpleTensor<TO> compute_reference(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, const PadStrideInfo &info,
                                       const Size2D &dilation, const ActivationLayerInfo act_info, PaddingList pre_pad_layer = PaddingList({}))
     {
         ARM_COMPUTE_ERROR_ON((input_shape[2] % weights_shape[2]) != 0);
@@ -534,19 +555,20 @@ class ConvolutionValidationGenericFixture : public framework::Fixture
             regularize_values(static_cast<void *>(src.data()), src.num_elements());
             regularize_values(static_cast<void *>(weights.data()), weights.num_elements());
         }
-
         if(pre_pad_layer.size() > 0)
         {
             src = reference::pad_layer<T>(src, pre_pad_layer, PixelValue(0), PaddingMode::CONSTANT);
         }
 
-        return (act_info.enabled()) ? reference::activation_layer<T>(reference::convolution_layer<T>(src, weights, bias, output_shape, info, dilation, num_groups, _dst_q_info),
+        auto res=  (act_info.enabled()) ? reference::activation_layer<TO>(reference::convolution_layer<T,TW,TBias,TO>(src, weights, bias, output_shape, info, dilation, num_groups, _dst_q_info),
                                                                      act_info) :
-               reference::convolution_layer<T>(src, weights, bias, output_shape, info, dilation, num_groups, _dst_q_info);
+               reference::convolution_layer<T,TW,TBias,TO>(src, weights, bias, output_shape, info, dilation, num_groups, _dst_q_info);
+
+        return res;
     }
 
     TensorType       _target{};
-    SimpleTensor<T>  _reference{};
+    SimpleTensor<TO>  _reference{};
     DataType         _data_type{};
     DataType         _weights_data_type{};
     DataType         _bias_data_type{};
@@ -602,14 +624,14 @@ class ConvolutionValidationWithPaddingFixture : public ConvolutionValidationGene
     }
 };
 
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, bool mixed_layout = false>
-class ConvolutionValidationQuantizedFixture : public ConvolutionValidationGenericFixture<TensorType, AccessorType, FunctionType, T, T>
+template <typename TensorType, typename AccessorType, typename FunctionType, typename T, bool mixed_layout = false, typename TO = T>
+class ConvolutionValidationQuantizedFixture : public ConvolutionValidationGenericFixture<TensorType, AccessorType, FunctionType, T, T, TO>
 {
 public:
     void setup(TensorShape input_shape, TensorShape weights_shape, TensorShape bias_shape, TensorShape output_shape, PadStrideInfo info, Size2D dilation, bool reshape_weights, DataType data_type,
                DataLayout data_layout, QuantizationInfo quantization_info, ActivationLayerInfo act_info)
     {
-        ConvolutionValidationGenericFixture<TensorType, AccessorType, FunctionType, T, T>::setup(input_shape, weights_shape, bias_shape, output_shape, info, dilation, reshape_weights,
+        ConvolutionValidationGenericFixture<TensorType, AccessorType, FunctionType, T, T, TO>::setup(input_shape, weights_shape, bias_shape, output_shape, info, dilation, reshape_weights,
                                                                                                  data_type, data_type, data_layout, quantization_info, quantization_info, act_info, mixed_layout);
     }
 };