Function validate_mm

src/gpu/cl/operators/ClFullyConnected.cpp:115–185

}

Status validate_mm(const ITensorInfo             &src,
                   const ITensorInfo             &weights,
                   const ITensorInfo             *bias,
                   const ITensorInfo             &dst,
                   const FullyConnectedLayerInfo &fc_info,
                   bool                           use_matmul)
{
    // Note : If input is dynamic and data is not batched, use matmul, else use gemm
    const bool transpose_weights = fc_info.transpose_weights ? !fc_info.are_weights_reshaped : false;
    const bool use_dynamic_gemm =
        !use_matmul && !weights.are_values_constant() && transpose_weights; // use dynamic gemm as fallback for matmul
    const bool is_quantized = is_data_type_quantized_asymmetric(src.data_type());

    if (use_matmul)
    {
        const MatMulInfo m_info = MatMulInfo().adj_rhs(transpose_weights);

        // Note: LHS is reshaped here to match ClMatMul expectations of batch index - From [M, B0, B1] to [M, 1, B0, B1]
        TensorInfo lhs_to_use = src.clone()->set_tensor_shape(get_reshaped_matmul_tensor(src.tensor_shape()));

        const GPUTarget                                         gpu_target = CLScheduler::get().target();
        std::unique_ptr<cl_matmul::IClMatMulNativeKernelConfig> t =
            cl_matmul::ClMatMulNativeKernelConfigurationFactory::create(gpu_target);
        const MatMulKernelInfo kernel_info = t->configure(&lhs_to_use, &weights, m_info);

        return is_quantized ? kernels::ClMatMulLowpNativeKernel::validate(&lhs_to_use, &weights, bias, &dst,
                                                                          kernel_info, fc_info.activation_info)
                            : kernels::ClMatMulNativeKernel::validate(&lhs_to_use, &weights, bias, &dst, kernel_info,
                                                                      fc_info.activation_info);
    }
    else
    {
        GEMMLowpOutputStageInfo gemmlowp_output_stage;
        ARM_COMPUTE_RETURN_ON_ERROR(
            construct_gemmlowp_output_stage(src, weights, dst, gemmlowp_output_stage, fc_info.activation_info));

        const GEMMInfo &gemm_info = GEMMInfo(false,                           // is_a_reshaped
                                             false,                           // is_b_reshaped
                                             !use_dynamic_gemm,               // reshape_b_only_on_first_run
                                             0,                               // depth_output_gemm3d
                                             false,                           // reinterpret_input_as_3d
                                             fc_info.retain_internal_weights, // retain_internal_weights
                                             gemmlowp_output_stage,           // gemmlowp_output_stage
                                             fc_info.fp_mixed_precision,      // fp_mixed_precision
                                             false,                           // fast_math
                                             true,                            // broadcast_bias
                                             ActivationLayerInfo());          // activation_info

        if (is_quantized)
        {
            const UniformQuantizationInfo iq_info = src.quantization_info().uniform();
            const UniformQuantizationInfo wq_info = weights.quantization_info().uniform();

            // Since we need negative offsets for computing convolution, we need to change QuantizationInfo()
            // Extract and negate src and weights offset
            const QuantizationInfo src_quantization_info(iq_info.scale, -iq_info.offset);
            const QuantizationInfo weights_quantization_info(wq_info.scale, -wq_info.offset);