Method configure

src/runtime/NEON/functions/NEDeconvolutionLayer.cpp:211–299

}

void NEDeconvolutionLayer::configure(ITensor             *input,
                                     const ITensor       *weights,
                                     const ITensor       *bias,
                                     ITensor             *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::configure");
    // Perform validation step
    ARM_COMPUTE_ERROR_ON_NULLPTR(input, weights, output);
    ARM_COMPUTE_ERROR_THROW_ON(NEDeconvolutionLayer::validate(input->info(), weights->info(),
                                                              (bias == nullptr) ? nullptr : bias->info(),
                                                              output->info(), info, enable_fast_math, weights_info));
    ARM_COMPUTE_LOG_PARAMS(input, weights, bias, output, info, enable_fast_math, weights_info);

    const DataLayout   data_layout = input->info()->data_layout();
    const unsigned int width_idx   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const unsigned int height_idx  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    auto               out_dims    = deconvolution_output_dimensions(
                         input->info()->dimension(width_idx), input->info()->dimension(height_idx),
                         weights->info()->dimension(width_idx), weights->info()->dimension(height_idx), info);

    const TensorShape output_shape = compute_deconvolution_output_shape(out_dims, *input->info(), *weights->info());

    _input            = input;
    _original_weights = weights;
    _info             = info;
    _is_prepared      = false;

    const unsigned int stride_x = info.stride().first;
    const unsigned int stride_y = info.stride().second;

    // Output auto initialization if not yet initialized
    auto_init_if_empty(*output->info(), output_shape, 1, input->info()->data_type(),
                       input->info()->quantization_info());

    _flip_axis.allocator()->init(TensorInfo(TensorShape(2U), 1, DataType::U32));

    _weights_flipped.allocator()->init(weights->info()->clone()->set_data_layout(data_layout));
    _flip_weights.configure(weights, &_weights_flipped, &_flip_axis);

    // setup the function to convolve the upscaled output
    uint32_t          deconv_pad_x    = 0;
    uint32_t          deconv_pad_y    = 0;
    const TensorShape scale_out_shape = compute_deconvolution_upsampled_shape(
        *input->info(), *weights->info(), stride_x, stride_y, out_dims, deconv_pad_x, deconv_pad_y);

    PadStrideInfo upsample_info;
    bool          negative_padding;
    std::tie(upsample_info, negative_padding) = compute_upsample_info(info, deconv_pad_x, deconv_pad_y);

    ARM_COMPUTE_ERROR_ON(negative_padding);
    // Do not perform upsampling when the operation uses unit stride in all dimensions
    _do_upsampling = stride_x != 1 || stride_y != 1;

    // Setup flip axis data
    _flip_axis.allocator()->allocate();