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.
- src/cpu/kernels/gemmlowp/generic/neon/impl.h
    neon_run_offset_contribution_float(): replace per-batch offset
    for vector_sum_col from Y stride to W stride.

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/kernels/gemmlowp/generic/neon/impl.h

@@ -66,8 +66,9 @@ void neon_run_offset_contribution_float(const Window  &window,
     const int window_step_x  = 16;
 
     // if vector_sum_col is nullptr then stride_y is 0, else get stride_y
-    const size_t sum_col_stride_y = (vector_sum_col != nullptr) ? (vector_sum_col->info()->strides_in_bytes().y()) : 0;
-    Iterator     mm_result_it(mm_result, collapsed_window);
+    const size_t sum_col_stride_w = (vector_sum_col != nullptr) ? vector_sum_col->info()->strides_in_bytes()[3] : 0;
+
+    Iterator mm_result_it(mm_result, collapsed_window);
 
     if ((a_offset != 0) && (b_offset != 0) && (vector_sum_col != nullptr) && (vector_sum_row != nullptr)) // true, true
     {
@@ -96,7 +97,7 @@ void neon_run_offset_contribution_float(const Window  &window,
             [&](const Coordinates &id)
             {
                 const int    batch_id         = id.z() / depth_input;
-                const size_t batch_offset_col = batch_id * sum_col_stride_y;
+                const size_t batch_offset_col = batch_id * sum_col_stride_w;
                 auto vector_sum_col_ptr = reinterpret_cast<const int32_t *>(vector_sum_col_it.ptr() + batch_offset_col +
                                                                             batch_id * vector_sum_col_batch_offset);
                 auto mm_result_ptr      = reinterpret_cast<T *>(mm_result_it.ptr());
@@ -216,7 +217,7 @@ void neon_run_offset_contribution_float(const Window  &window,
                 const int    batch_id = id.z() / depth_input;
                 const size_t batch_offset_col =
                     batch_id *
-                    sum_col_stride_y; // Value to offset vector_sum_col_ptr to allow for iteration of y values in tensor
+                    sum_col_stride_w; // Value to offset vector_sum_col_ptr to allow for iteration of y values in tensor
                 auto vector_sum_col_ptr = reinterpret_cast<const int32_t *>(vector_sum_col_it.ptr() + batch_offset_col +
                                                                             batch_id * vector_sum_col_batch_offset);
                 auto mm_result_ptr      = reinterpret_cast<T *>(mm_result_it.ptr());

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 */,
@@ -367,14 +384,30 @@ Status CpuGemmConv2d::validate_mm(const ITensorInfo         *src,
         {
             std::tie(min_activation, max_activation) = get_quantized_activation_min_max(act_info, data_type, uoqinfo);
         }
-
+        // F32 dequant path? (input quantized, output float)
+        const bool              dequantize_f32 = (dst->data_type() == DataType::F32);
         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 = (weights->data_type() == DataType::QSYMM8_PER_CHANNEL);
-        ARM_COMPUTE_RETURN_ON_ERROR(quantization::calculate_quantized_multipliers(iqinfo, wqinfo, oqinfo, output_info));
+
+        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 = (weights->data_type() == DataType::QSYMM8_PER_CHANNEL);
+            ARM_COMPUTE_RETURN_ON_ERROR(
+                quantization::calculate_quantized_multipliers(iqinfo, wqinfo, oqinfo, output_info));
+        }
 
         // Perform validation step on GEMMLowp
         std::unique_ptr<ITensorInfo> input_qa   = src->clone();
@@ -504,9 +537,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 +760,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 +818,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

@@ -132,10 +132,17 @@ void CpuGemmLowpMatrixMultiplyCore::configure(
                        _reshape_b_only_on_first_run;
     _gemm_info = gemm_info;
 
-    const ITensorInfo *a_to_use = a;
-
+    // F32 dequant path? (input quantized, output float)
+    const bool         dequantize_f32 = a->data_type() == DataType::QASYMM8_SIGNED && dst->data_type() == DataType::F32;
+    const ITensorInfo *a_to_use       = a;
     // Initialize assembly kernel meta-data
-    const cpu::AsmGemmInfo asm_info = init_assembly_metadata(gemm_info);
+    cpu::AsmGemmInfo asm_info = init_assembly_metadata(gemm_info);
+    if (dequantize_f32)
+    {
+        // We don't want arm_gemm to compute the activations because bias and offsets are added in ACL at a later step
+        // so we disable activation in arm_gemm and run it as a post op in ACL
+        asm_info.activation_info = arm_compute::ActivationLayerInfo();
+    }
 
     const int32_t                 offset_correction = 128;
     const DataType                dt                = DataType::QASYMM8_SIGNED;
@@ -151,7 +158,6 @@ void CpuGemmLowpMatrixMultiplyCore::configure(
     {
         _flip_signedness = true;
     }
-
     _asm_glue = std::make_unique<cpu::CpuGemmAssemblyDispatch>();
 
     // Convert to QASYMM8 -> QASYMM8_SIGNED and back
@@ -200,7 +206,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;
@@ -310,8 +316,9 @@ void CpuGemmLowpMatrixMultiplyCore::configure(
     }
     // Configure activation
     const ActivationLayerInfo &activation = gemm_info.activation_info();
-    _run_activation =
-        activation.enabled() && (!_assembly_path || !cpu::CpuGemmAssemblyDispatch::is_activation_supported(activation));
+
+    _run_activation = activation.enabled() && (dequantize_f32 || !_assembly_path ||
+                                               !cpu::CpuGemmAssemblyDispatch::is_activation_supported(activation));
     if (_run_activation)
     {
         _activation_func = std::make_unique<CpuActivation>();
@@ -488,6 +495,41 @@ Status CpuGemmLowpMatrixMultiplyCore::validate(const ITensorInfo *a,
         {
             ARM_COMPUTE_RETURN_ERROR_ON(a->dimension(1) != output->dimension(1));
         }
+
+        // Q -> F32 path, we add offsets in ACL so we need to validate:
+        // CpuGemmLowpMatrixAReductionKernel
+        // CpuGemmLowpMatrixAReductionKernel
+        if (a->data_type() == DataType::QASYMM8_SIGNED && output->data_type() == DataType::F32)
+        {
+            TensorInfo info_vector_sum_col{};
+            TensorInfo info_vector_sum_row{};
+
+            const GEMMLowpReductionKernelInfo reduction_info(a_to_use->dimension(0), false, 0, false);
+
+            // Validate matrix B reduction kernel only if _a_offset is not equal to 0
+            if (a_offset_kernel_needed)
+            {
+                info_vector_sum_col = TensorInfo(compute_reductionA_shape(*b), 1, DataType::S32);
+
+                // Configure Matrix B reduction kernel
+                ARM_COMPUTE_RETURN_ON_ERROR(
+                    kernels::CpuGemmLowpMatrixBReductionKernel::validate(b, &info_vector_sum_col, reduction_info));
+            }
+
+            // Validate Matrix A reduction kernel only if _b_offset is not equal to 0
+            if (b_offset_kernel_needed)
+            {
+                info_vector_sum_row = TensorInfo(compute_reductionB_shape(*a), 1, DataType::S32);
+
+                // Configure matrix A reduction kernel
+                ARM_COMPUTE_RETURN_ON_ERROR(kernels::CpuGemmLowpMatrixAReductionKernel::validate(
+                    a_to_use, &info_vector_sum_row, reduction_info));
+            }
+
+            ARM_COMPUTE_RETURN_ON_ERROR(kernels::CpuGemmLowpOffsetContributionKernel::validate(
+                output, a_offset_kernel_needed ? &info_vector_sum_col : nullptr,
+                b_offset_kernel_needed ? &info_vector_sum_row : nullptr, a_offset, b_offset));
+        }
     }
     else
     {

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) })),
+                                                            ActivationFunctionsDataset))
+{
+    // 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)),