Method validate

src/runtime/NEON/functions/NEDeconvolutionLayer.cpp:95–209

}

Status NEDeconvolutionLayer::validate(const ITensorInfo   *input,
                                      const ITensorInfo   *weights,
                                      const ITensorInfo   *bias,
                                      const ITensorInfo   *output,
                                      const PadStrideInfo &info,
                                      bool                 enable_fast_math,
                                      const WeightsInfo   &weights_info)
{
    ARM_COMPUTE_TRACE_EVENT(ARM_COMPUTE_PROF_CAT_CPU, ARM_COMPUTE_PROF_LVL_CPU, "NEDeconvolutionLayer::validate");
    ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, weights, output);
    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F32, DataType::F16, DataType::QASYMM8,
                                                         DataType::QASYMM8_SIGNED);
    ARM_COMPUTE_RETURN_ERROR_ON_DYNAMIC_SHAPE(input, weights, bias, output);
    const unsigned int width_idx = get_data_layout_dimension_index(weights->data_layout(), DataLayoutDimension::WIDTH);
    const unsigned int height_idx =
        get_data_layout_dimension_index(weights->data_layout(), DataLayoutDimension::HEIGHT);
    ARM_COMPUTE_RETURN_ERROR_ON(weights->dimension(width_idx) < 1);
    ARM_COMPUTE_RETURN_ERROR_ON(weights->dimension(height_idx) < 1);
    ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT(weights, input);
    if (is_data_type_quantized_per_channel(weights->data_type()) && is_data_type_quantized(input->data_type()))
    {
        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(weights, 1, DataType::QSYMM8_PER_CHANNEL);
    }
    else
    {
        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, weights);
    }

    const unsigned int pad_left   = info.pad_left();
    const unsigned int pad_top    = info.pad_top();
    const unsigned int pad_right  = info.pad_right();
    const unsigned int pad_bottom = info.pad_bottom();

    ARM_COMPUTE_RETURN_ERROR_ON(((input->dimension(width_idx) - 1) * info.stride().first +
                                 weights->dimension(width_idx)) < (pad_left + pad_right));
    ARM_COMPUTE_RETURN_ERROR_ON(((input->dimension(height_idx) - 1) * info.stride().second +
                                 weights->dimension(height_idx)) < (pad_top + pad_bottom));

    auto out_dims =
        deconvolution_output_dimensions(input->dimension(width_idx), input->dimension(height_idx),
                                        weights->dimension(width_idx), weights->dimension(height_idx), info);

    if (bias != nullptr)
    {
        if (is_data_type_quantized_asymmetric(input->data_type()))
        {
            ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(bias, 1, DataType::S32);
        }
        else
        {
            ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, bias);
        }
    }

    if (output->tensor_shape().total_size() > 0)
    {
        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);