arm_compute::NETransposeConvLayer Class Reference

#include <NETransposeConvLayer.h>

Collaboration diagram for arm_compute::NETransposeConvLayer:

Public Member Functions
	NETransposeConvLayer (std::shared_ptr< IMemoryManager > memory_manager=nullptr)
	NETransposeConvLayer (const NETransposeConvLayer &)=delete
NETransposeConvLayer &	operator= (const NETransposeConvLayer &)=delete
	NETransposeConvLayer (NETransposeConvLayer &&)=delete
NETransposeConvLayer &	operator= (NETransposeConvLayer &&)=delete
virtual	~NETransposeConvLayer ()=default
void	configure (ITensor *input, const ITensor *weights, const ITensor *bias, ITensor *output, const PadStrideInfo &info, unsigned int invalid_right, unsigned int invalid_bottom)
void	run () override
void	prepare () override

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

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 perfrom a 1x1 convolution pass. Input stride defines how many zeroes we should put between each element of the input, pad is the amount of padding and finaly a is a user specified value where a < stride - 1 that increases the padding top and right of the input image.

The relation between input to output is as follows:

where width is the size of the first input dimension. height 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 NEReverse.

This function calls the following NEON kernels/functions:

1. CPPUpsampleEx
2. NEConvolutionLayer
3. NEPermute
4. NEReverse

Definition at line 94 of file NETransposeConvLayer.h.

Constructor & Destructor Documentation

NETransposeConvLayer() [1/3]

arm_compute::NETransposeConvLayer::NETransposeConvLayer

(

std::shared_ptr< IMemoryManager >

memory_manager = nullptr

)

Constructor

Definition at line 54 of file NETransposeConvLayer.cpp.

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

NETransposeConvLayer() [2/3]

arm_compute::NETransposeConvLayer::NETransposeConvLayer ( const NETransposeConvLayer &  )

delete

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

NETransposeConvLayer() [3/3]

arm_compute::NETransposeConvLayer::NETransposeConvLayer ( NETransposeConvLayer &&  )

delete

Allow instances of this class to be moved

~NETransposeConvLayer()

virtual arm_compute::NETransposeConvLayer::~NETransposeConvLayer ( )

virtualdefault

Default destructor

References validate().

Member Function Documentation

configure()

void arm_compute::NETransposeConvLayer::configure	(	ITensor *	input,
		const ITensor *	weights,
		const ITensor *	bias,
		ITensor *	output,
		const PadStrideInfo &	info,
		unsigned int	invalid_right,
		unsigned int	invalid_bottom
	)

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: F32/F16/QASYMM8/QASYMM8_SIGNED.
[in]	weights	The 4d weights with dimensions [width, height, IFM, OFM]. Data type supported: Same as input.
[in]	bias	Optional, ignored if NULL. The biases have one dimension. Data type supported: Data types supported: S32 for QASYMM8 and QASYMM8_SIGNED input, F32 for F32 input, F16 for F16 input.
[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.

Definition at line 135 of file NETransposeConvLayer.cpp.

{
  // Perform validation step
  ARM_COMPUTE_ERROR_ON_NULLPTR(input, weights, output);
  ARM_COMPUTE_ERROR_THROW_ON(NETransposeConvLayer::validate(
    input->info(), weights->info(), (bias == nullptr) ? nullptr : bias->info(), output->info(),
    info, invalid_right, invalid_bottom));
 
  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 = transposeconv_output_dimensions(
    input->info()->dimension(width_idx), input->info()->dimension(height_idx),
    weights->info()->dimension(width_idx), weights->info()->dimension(height_idx), info,
    invalid_right, invalid_bottom);
 
  const TensorShape output_shape =
    compute_transposeconv_output_shape(out_dims, *input->info(), *weights->info());
 
  _input = input;
  _original_weights = weights;
  _info = info;
  _is_prepared = false;
 
  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;
 
  // 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));
  _memory_group.manage(&_scaled_output);
 
  _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
  const PadStrideInfo conv_info(1, 1, 0, 0, 0, 0, DimensionRoundingType::CEIL);
 
  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);
 
  const PadStrideInfo upsample_info(stride_x, stride_y, pad_left, pad_right, pad_top, pad_bottom,
                                    DimensionRoundingType::FLOOR);
 
  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);
 
  _upsample_f.configure(input, &_scaled_output, upsample_info);
 
  _conv_f.configure(&_scaled_output, &_weights_flipped, bias, output, conv_info);
 
  // Setup flip axis data
  _flip_axis.allocator()->allocate();
  auto axis_data = reinterpret_cast<uint32_t *>(_flip_axis.buffer());
  axis_data[0] = static_cast<uint32_t>(width_idx);
  axis_data[1] = static_cast<uint32_t>(height_idx);
 
  _scaled_output.allocator()->allocate();
}

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().

operator=() [1/2]

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

delete

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

operator=() [2/2]

NETransposeConvLayer & arm_compute::NETransposeConvLayer::operator= ( NETransposeConvLayer &&  )

delete

Allow instances of this class to be moved

prepare()

void arm_compute::NETransposeConvLayer::prepare ( )

override

Definition at line 218 of file NETransposeConvLayer.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();
 
    _is_prepared = true;
  }
}

Referenced by run().

run()

void arm_compute::NETransposeConvLayer::run ( )

override

Definition at line 208 of file NETransposeConvLayer.cpp.

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

References prepare().

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

validate()

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

static

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

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: F32/F16/QASYMM8/QASYMM8_SIGNED.
[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 types supported: S32 for QASYMM8 and QASYMM8_SIGNED input, F32 for F32 input, F16 for F16 input.
[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]	innvalid_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.

Returns

a status

Definition at line 61 of file NETransposeConvLayer.cpp.

{
  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_MISMATCHING_DATA_TYPES(weights, input);
  ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT(weights, input);
  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) != weights->dimension(height_idx));
  ARM_COMPUTE_RETURN_ERROR_ON(weights->dimension(width_idx) < 1);
 
  auto out_dims = transposeconv_output_dimensions(
    input->dimension(width_idx), input->dimension(height_idx), weights->dimension(width_idx),
    weights->dimension(height_idx), info, invalid_right, invalid_bottom);
 
  ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, 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);
    }
  }
 
  if (output->tensor_shape().total_size() > 0)
  {
    ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
 
    const TensorShape output_shape = compute_transposeconv_output_shape(out_dims, *input, *weights);
 
    ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->dimension(Window::DimX) != output_shape.x(),
                                    "Output's width is invalid.");
    ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->dimension(Window::DimY) != output_shape.y(),
                                    "Output's height is invalid.");
    ARM_COMPUTE_RETURN_ERROR_ON_MSG(output->dimension(Window::DimZ) != output_shape.z(),
                                    "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));
  const PadStrideInfo conv_info(1, 1, 0, 0, 0, 0, DimensionRoundingType::CEIL);
 
  const unsigned int batches_idx =
    get_data_layout_dimension_index(weights->data_layout(), DataLayoutDimension::BATCHES);
  const unsigned int channel_idx =
    get_data_layout_dimension_index(weights->data_layout(), DataLayoutDimension::CHANNEL);
  ARM_COMPUTE_RETURN_ERROR_ON(input->dimension(batches_idx) !=
                              scale_out_info.dimension(batches_idx));
  ARM_COMPUTE_RETURN_ERROR_ON(input->dimension(channel_idx) !=
                              scale_out_info.dimension(channel_idx));
 
  ARM_COMPUTE_RETURN_ON_ERROR(
    NEConvolutionLayer::validate(&scale_out_info, weights, bias, output, conv_info, WeightsInfo()));
 
  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(), and ~NETransposeConvLayer().

---

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

• compute/ARMComputeEx/arm_compute/runtime/NEON/functions/NETransposeConvLayer.h
• compute/ARMComputeEx/src/runtime/NEON/functions/NETransposeConvLayer.cpp