Method validate

src/gpu/cl/operators/ClFullyConnected.cpp:464–577

}

Status ClFullyConnected::validate(const ITensorInfo      *src,
                                  const ITensorInfo      *weights,
                                  const ITensorInfo      *biases,
                                  const ITensorInfo      *dst,
                                  FullyConnectedLayerInfo fc_info)
{
    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(src, weights, dst);
    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(src, 1, DataType::QASYMM8, DataType::QASYMM8_SIGNED,
                                                         DataType::F16, DataType::F32);
    ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(src, weights, dst);
    ARM_COMPUTE_RETURN_ERROR_ON(weights->num_dimensions() > 2);
    ARM_COMPUTE_RETURN_ERROR_ON(
        fc_info.activation_info.enabled() && is_data_type_quantized(src->data_type()) &&
        fc_info.activation_info.activation() != ActivationLayerInfo::ActivationFunction::RELU &&
        fc_info.activation_info.activation() != ActivationLayerInfo::ActivationFunction::BOUNDED_RELU &&
        fc_info.activation_info.activation() != ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU);
    const GPUTarget gpu_target = get_arch_from_target(CLScheduler::get().target());

    const bool transpose_weights = fc_info.transpose_weights ? !fc_info.are_weights_reshaped : false;
    bool       is_fc_after_conv  = true;

    // When using dynamic weights - use matmul kernels.
    // Note: MatMul does not support broadcasting so fallback with batched cases.
    const bool is_batched_fc_layer = dst->dimension(1) > 1;
    const bool use_matmul          = gpu_target != GPUTarget::MIDGARD && !weights->are_values_constant() &&
                            !is_batched_fc_layer &&
                            !(src->num_dimensions() > 1 && (src->data_layout() != fc_info.weights_trained_layout));

    const ITensorInfo &flatten_src      = TensorInfo(src->clone()
                                                         ->set_is_resizable(true)
                                                         .reset_padding()
                                                         .set_tensor_shape(compute_flatten_shape(src))
                                                         .set_data_layout(DataLayout::NCHW));
    const ITensorInfo &reshaped_weights = TensorInfo(
        weights->clone()->set_is_resizable(true).reset_padding().set_tensor_shape(compute_transposed_shape(*weights)));
    const ITensorInfo &converted_weights = (transpose_weights && !use_matmul)
                                               ? TensorInfo(*reshaped_weights.clone())
                                               : TensorInfo(weights->clone()->set_is_resizable(true).reset_padding());

    // With the Fully Connected layer we can have 4 different cases:
    //  1) Convolution layer -> Fully Connected layer without batches
    //  2) Fully Connected layer -> Fully Connected layer without batches
    //  3) Convolution layer -> Fully Connected layer with batches
    //  4) Fully Connected layer -> Fully Connected layer with batches

    const ITensorInfo *src_to_use     = src;
    const ITensorInfo *weights_to_use = weights;

    if (biases != nullptr)
    {
        ARM_COMPUTE_RETURN_ERROR_ON(biases->num_dimensions() > 1);
        if (is_data_type_quantized(src->data_type()))
        {
            ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(biases, 1, DataType::S32);
        }
        else
        {
            ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(src, biases);