arm_compute::CLDirectTransposeConvLayer Class Reference

#include <CLDirectTransposeConvLayer.h>

Collaboration diagram for arm_compute::CLDirectTransposeConvLayer:

Public Member Functions
	CLDirectTransposeConvLayer (std::shared_ptr< IMemoryManager > memory_manager=nullptr)
	CLDirectTransposeConvLayer (const CLDirectTransposeConvLayer &)=delete
	CLDirectTransposeConvLayer (CLDirectTransposeConvLayer &&)=default
CLDirectTransposeConvLayer &	operator= (const CLDirectTransposeConvLayer &)=delete
CLDirectTransposeConvLayer &	operator= (CLDirectTransposeConvLayer &&)=default
void	configure (ICLTensor *input, ICLTensor *weights, const ICLTensor *bias, ICLTensor *output, const PadStrideInfo &info, unsigned int invalid_right, unsigned int invalid_bottom, const WeightsInfo &weights_info=WeightsInfo())
void	configure (const CLCompileContext &compile_context, ICLTensor *input, ICLTensor *weights, const ICLTensor *bias, ICLTensor *output, const PadStrideInfo &info, unsigned int invalid_right, unsigned int invalid_bottom, const WeightsInfo &weights_info=WeightsInfo())
void	run () override
void	prepare () override

Static Public Member Functions
static Status	validate (const ITensorInfo *input, const ITensorInfo *weights, const ITensorInfo *bias, ITensorInfo *output, const PadStrideInfo &info, unsigned int invalid_right, unsigned int invalid_bottom, const WeightsInfo &weights_info=WeightsInfo())

Detailed Description

Function to run the deconvolution layer.

Deconvolution Layer is the backward pass of Convolution Layer. First we transform the input depending on the stride and pad info and then perform a 1x1 convolution pass. Input stride defines how many zeroes we should put between each element of the input and pad is the amount of padding.

The relation between input to output is as follows:

where: width_input is the size of the first input dimension. height_input is the size of the second input dimension. width_output is the size of the first output dimension. height_output is the size of the second output dimension. kernel_x and kernel_y are the convolution sizes in x and y. stride_x and stride_y is the input stride of the first and second dimension.

The weights used by Deconvolution are supposed to be the same as the ones used for Convolution. Therefore, it will be necessary to use the weights in the reverse order to perform an actual convolution. This is achieved by using CLReverse.

This function calls the following OpenCL kernels/functions:

1. CLDeconvolutionLayerUpsample
2. CLConvolutionLayer

And the following CPP kernels:

1. CLReverse

Definition at line 94 of file CLDirectTransposeConvLayer.h.

Constructor & Destructor Documentation

CLDirectTransposeConvLayer() [1/3]

arm_compute::CLDirectTransposeConvLayer::CLDirectTransposeConvLayer

(

std::shared_ptr< IMemoryManager >

memory_manager = nullptr

)

Constructor

Definition at line 58 of file CLDirectTransposeConvLayer.cpp.

  : _memory_group(std::move(memory_manager)), _scale_f(), _conv_f(), _flip_weights(),
    _scaled_output(), _original_weights(nullptr), _weights_flipped(), _flip_axis(),
    _is_prepared(false)
{
}

CLDirectTransposeConvLayer() [2/3]

arm_compute::CLDirectTransposeConvLayer::CLDirectTransposeConvLayer ( const CLDirectTransposeConvLayer &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

CLDirectTransposeConvLayer() [3/3]

arm_compute::CLDirectTransposeConvLayer::CLDirectTransposeConvLayer ( CLDirectTransposeConvLayer &&  )

default

Default move constructor

Member Function Documentation

configure() [1/2]

void arm_compute::CLDirectTransposeConvLayer::configure	(	const CLCompileContext &	compile_context,
		ICLTensor *	input,
		ICLTensor *	weights,
		const ICLTensor *	bias,
		ICLTensor *	output,
		const PadStrideInfo &	info,
		unsigned int	invalid_right,
		unsigned int	invalid_bottom,
		const WeightsInfo &	weights_info = WeightsInfo()
	)

Set the input, weights, biases and output tensors.

Parameters

[in]	compile_context	The compile context to be used.
[in,out]	input	Input tensor. 3 lower dimensions represent a single input, and an optional 4th dimension for batch of inputs. Data types supported: QASYMM8_SIGNED/QASYMM8/F16/F32.
[in]	weights	The 4d weights with dimensions [width, height, IFM, OFM]. Data type supported: Same as input.
[in]	bias	(Optional) The biases have one dimension. Data type supported: Should match input data type, except for input of QASYMM8 and QASYMM8_SIGNED type where biases should be of S32 type
[out]	output	Output tensor. The output has the same number of dimensions as the input.
[in]	info	Contains padding and policies to be used in the deconvolution, this is decribed in PadStrideInfo.
[in]	invalid_right	The number of zeros added to right edge of the output.
[in]	invalid_bottom	The number of zeros added to bottom edge of the output.
[in]	weights_info	(Optional) Weights information needed for CLConvolutionLayer, specifies if the weights tensor has been reshaped with CLWeightsReshapeKernel.

Definition at line 144 of file CLDirectTransposeConvLayer.cpp.

{
  ARM_COMPUTE_ERROR_ON_NULLPTR(input, weights, output);
 
  unsigned int pad_left = 0;
  unsigned int pad_right = 0;
  unsigned int pad_top = 0;
  unsigned int pad_bottom = 0;
  const unsigned int stride_x = info.stride().first;
  const unsigned int stride_y = info.stride().second;
 
  const DataLayout data_layout = input->info()->data_layout();
 
  const size_t idx_w = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
  const size_t idx_h = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
 
  _original_weights = weights;
  _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(compile_context, weights, &_weights_flipped, &_flip_axis, false);
 
  auto out_dims = transposeconv_output_dimensions(
    input->info()->dimension(idx_w), input->info()->dimension(idx_h),
    weights->info()->dimension(idx_w), weights->info()->dimension(idx_h), info, invalid_right,
    invalid_bottom);
 
  const TensorShape output_shape =
    compute_transposeconv_output_shape(out_dims, *input->info(), *weights->info());
 
  // Output auto initialization if not yet initialized
  auto_init_if_empty(
    *output->info(),
    input->info()->clone()->set_tensor_shape(output_shape).set_data_layout(data_layout));
 
  // Perform validation step
  ARM_COMPUTE_ERROR_THROW_ON(CLDirectTransposeConvLayer::validate(
    input->info(), weights->info(), bias == nullptr ? nullptr : bias->info(), output->info(), info,
    invalid_right, invalid_bottom));
 
  _is_prepared = weights_info.retain_internal_weights();
 
  _memory_group.manage(&_scaled_output);
 
  // Find the upsampled dimensions and the padding needed for the convolution with stride 1 in order
  // to match output shape
  const TensorShape scale_out_shape = compute_transposeconv_upsampled_shape(
    *input->info(), *weights->info(), info, out_dims, invalid_right, invalid_bottom, pad_left,
    pad_right, pad_top, pad_bottom);
 
  TensorInfo scale_out_info(scale_out_shape, 1, input->info()->data_type(),
                            input->info()->quantization_info());
  scale_out_info.set_data_layout(data_layout);
  _scaled_output.allocator()->init(scale_out_info);
 
  // configure scale function
  const PadStrideInfo upsample_info(stride_x, stride_y, pad_left, pad_right, pad_top, pad_bottom,
                                    DimensionRoundingType::FLOOR);
  _scale_f.configure(input, &_scaled_output, upsample_info);
 
  // Setup the function to convolve the upscaled output
  const PadStrideInfo conv_info(1, 1, 0, 0, 0, 0, DimensionRoundingType::CEIL);
  _conv_f.configure(compile_context, &_scaled_output, &_weights_flipped, bias, output, conv_info,
                    weights_info);
  _scaled_output.allocator()->allocate();
 
  // Setup flip axis data
  _flip_axis.allocator()->allocate();
  _flip_axis.map(true);
  auto axis_data = reinterpret_cast<uint32_t *>(_flip_axis.buffer());
  if (weights->info()->data_layout() == DataLayout::NHWC)
  {
    axis_data[0] = 1;
    axis_data[1] = 2;
  }
  else
  {
    axis_data[0] = 0;
    axis_data[1] = 1;
  }
  _flip_axis.unmap();
}

References arm_compute::misc::shape_calculator::compute_transposeconv_output_shape(), arm_compute::misc::shape_calculator::compute_transposeconv_upsampled_shape(), info, output_shape, arm_compute::transposeconv_output_dimensions(), and validate().

configure() [2/2]

void arm_compute::CLDirectTransposeConvLayer::configure	(	ICLTensor *	input,
		ICLTensor *	weights,
		const ICLTensor *	bias,
		ICLTensor *	output,
		const PadStrideInfo &	info,
		unsigned int	invalid_right,
		unsigned int	invalid_bottom,
		const WeightsInfo &	weights_info = WeightsInfo()
	)

Set the input, weights, biases and output tensors.

Parameters

[in,out]	input	Input tensor. 3 lower dimensions represent a single input, and an optional 4th dimension for batch of inputs. Data types supported: QASYMM8_SIGNED/QASYMM8/F16/F32.
[in]	weights	The 4d weights with dimensions [width, height, IFM, OFM]. Data type supported: Same as input.
[in]	bias	(Optional) The biases have one dimension. Data type supported: Should match input data type, except for input of QASYMM8 and QASYMM8_SIGNED type where biases should be of S32 type
[out]	output	Output tensor. The output has the same number of dimensions as the input.
[in]	info	Contains padding and policies to be used in the deconvolution, this is decribed in PadStrideInfo.
[in]	invalid_right	The number of zeros added to right edge of the output.
[in]	invalid_bottom	The number of zeros added to bottom edge of the output.
[in]	weights_info	(Optional) Weights information needed for CLConvolutionLayer, specifies if the weights tensor has been reshaped with CLWeightsReshapeKernel.

Definition at line 134 of file CLDirectTransposeConvLayer.cpp.

{
  configure(CLKernelLibrary::get().get_compile_context(), input, weights, bias, output, info,
            invalid_right, invalid_bottom, weights_info);
}

References configure(), and info.

Referenced by configure().

operator=() [1/2]

CLDirectTransposeConvLayer & arm_compute::CLDirectTransposeConvLayer::operator= ( CLDirectTransposeConvLayer &&  )

default

Default move assignment operator

References validate().

operator=() [2/2]

CLDirectTransposeConvLayer & arm_compute::CLDirectTransposeConvLayer::operator= ( const CLDirectTransposeConvLayer &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

prepare()

void arm_compute::CLDirectTransposeConvLayer::prepare ( )

override

Definition at line 241 of file CLDirectTransposeConvLayer.cpp.

{
  if (!_is_prepared)
  {
    ARM_COMPUTE_ERROR_ON(!_original_weights->is_used());
 
    // Run weights flipping and mark original weights tensor as unused
    _weights_flipped.allocator()->allocate();
    _flip_weights.run();
    _original_weights->mark_as_unused();
 
    // Prepare convolution
    _conv_f.prepare();
 
    // Free flipped weights
    if (!_weights_flipped.is_used())
    {
      _weights_flipped.allocator()->free();
    }
 
    _is_prepared = true;
  }
}

Referenced by run().

run()

void arm_compute::CLDirectTransposeConvLayer::run ( )

override

Definition at line 231 of file CLDirectTransposeConvLayer.cpp.

{
  prepare();
 
  MemoryGroupResourceScope scope_mg(_memory_group);
 
  _scale_f.run();
  _conv_f.run();
}

References prepare().

Referenced by package.infer.session::inference().

validate()

Status arm_compute::CLDirectTransposeConvLayer::validate ( const ITensorInfo *  input, const ITensorInfo *  weights, const ITensorInfo *  bias, ITensorInfo *  output, const PadStrideInfo &  info, unsigned int  invalid_right, unsigned int  invalid_bottom, const WeightsInfo &  weights_info = WeightsInfo()  )

static

Static function to check if given info will lead to a valid configuration of CLDirectTransposeConvLayer

Parameters

[in]	input	Input tensor info. 3 lower dimensions represent a single input, and an optional 4th dimension for batch of inputs. Data types supported: QASYMM8_SIGNED/QASYMM8/F16/F32.
[in]	weights	The 4d weights info with dimensions [width, height, IFM, OFM]. Data type supported: Same as input.
[in]	bias	(Optional) The biases have one dimension. Data type supported: Should match input data type, except for input of QASYMM8 and QASYMM8_SIGNED type where biases should be of S32 type
[in]	output	Output tensor info. The output has the same number of dimensions as the input.
[in]	info	Contains padding and policies to be used in the deconvolution, this is decribed in PadStrideInfo.
[in]	invalid_right	The number of zeros added to right edge of the output.
[in]	invalid_bottom	The number of zeros added to bottom edge of the output.
[in]	weights_info	(Optional) Weights information needed for CLConvolutionLayer, specifies if the weights tensor has been reshaped with CLWeightsReshapeKernel.

Returns

a status

Definition at line 66 of file CLDirectTransposeConvLayer.cpp.

{
  ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, weights, output);
  ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(
    input, 1, DataType::QASYMM8_SIGNED, DataType::QASYMM8, DataType::F16, DataType::F32);
  ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT(input, weights);
  const DataLayout data_layout = input->data_layout();
 
  const size_t idx_w = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
  const size_t idx_h = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
  const size_t idx_c = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
  ARM_COMPUTE_RETURN_ERROR_ON(weights->dimension(idx_w) != weights->dimension(idx_h));
  ARM_COMPUTE_RETURN_ERROR_ON(weights->dimension(idx_w) < 1);
 
  auto out_dims = transposeconv_output_dimensions(
    input->dimension(idx_w), input->dimension(idx_h), weights->dimension(idx_w),
    weights->dimension(idx_h), info, invalid_right, invalid_bottom);
 
  const TensorShape output_shape = compute_transposeconv_output_shape(out_dims, *input, *weights);
 
  ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output, weights);
 
  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);
    }
    ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT(input, bias);
  }
 
  ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->dimension(idx_w) != output_shape[idx_w],
                                  "Output's width is invalid.");
  ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->dimension(idx_h) != output_shape[idx_h],
                                  "Output's height is invalid.");
  ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->dimension(idx_c) != output_shape[idx_c],
                                  "Output's depth is invalid.");
 
  unsigned int pad_left = 0;
  unsigned int pad_right = 0;
  unsigned int pad_top = 0;
  unsigned int pad_bottom = 0;
  const TensorShape scale_out_shape =
    compute_transposeconv_upsampled_shape(*input, *weights, info, out_dims, invalid_right,
                                          invalid_bottom, pad_left, pad_right, pad_top, pad_bottom);
  TensorInfo scale_out_info(input->clone()
                              ->set_is_resizable(true)
                              .reset_padding()
                              .set_tensor_shape(scale_out_shape)
                              .set_data_layout(data_layout));
  const PadStrideInfo conv_info(1, 1, 0, 0, 0, 0, DimensionRoundingType::CEIL);
 
  ARM_COMPUTE_RETURN_ON_ERROR(CLDeconvolutionLayerUpsample::validate(input, &scale_out_info, info));
  ARM_COMPUTE_RETURN_ON_ERROR(
    CLConvolutionLayer::validate(&scale_out_info, weights, bias, output, conv_info, weights_info));
 
  return Status{};
}

References arm_compute::misc::shape_calculator::compute_transposeconv_output_shape(), arm_compute::misc::shape_calculator::compute_transposeconv_upsampled_shape(), info, output_shape, and arm_compute::transposeconv_output_dimensions().

Referenced by configure(), operator=(), and arm_compute::CLTransposeConvLayer::validate().

---

The documentation for this class was generated from the following files:

• compute/ARMComputeEx/arm_compute/runtime/CL/functions/CLDirectTransposeConvLayer.h
• compute/ARMComputeEx/src/runtime/CL/functions/CLDirectTransposeConvLayer.cpp