#include <CLFullyConnectedLayerEx.h>

Collaboration diagram for arm_compute::CLFullyConnectedLayerEx:

Public Member Functions
	CLFullyConnectedLayerEx (std::shared_ptr< IMemoryManager > memory_manager=nullptr, IWeightsManager *weights_manager=nullptr)

	CLFullyConnectedLayerEx (const CLFullyConnectedLayerEx &)=delete

	CLFullyConnectedLayerEx (CLFullyConnectedLayerEx &&)=default

CLFullyConnectedLayerEx &	operator= (const CLFullyConnectedLayerEx &)=delete

CLFullyConnectedLayerEx &	operator= (CLFullyConnectedLayerEx &&)=default

void	configure (const ICLTensor input, const ICLTensor weights, const ICLTensor biases, ICLTensor output, FullyConnectedLayerInfo fc_info=FullyConnectedLayerInfo())

void	run () override

void	prepare () override

Static Public Member Functions
static Status	validate (const ITensorInfo input, const ITensorInfo weights, const ITensorInfo biases, const ITensorInfo output, FullyConnectedLayerInfo fc_info=FullyConnectedLayerInfo())

Detailed Description

Basic function to compute a Fully Connected layer on OpenCL. This function calls the following OpenCL kernels:

CLIm2ColKernel (called when the input comes from a convolutional layer)
CLFullyConnectedLayerReshapeWeightsEx (if are_weights_reshaped is set to false and transpose_weights is set to true ) (called once)
CLGEMMMatrixMultiplyKernel or CLGEMMLowpMatrixMultiplyCore (if quantized asymmetric)

Note: The fully connected layer accepts "weights" tensors only with 2 dimensions.

Definition at line 106 of file CLFullyConnectedLayerEx.h.

Constructor & Destructor Documentation

◆ CLFullyConnectedLayerEx() [1/3]

arm_compute::CLFullyConnectedLayerEx::CLFullyConnectedLayerEx	(	std::shared_ptr< IMemoryManager >	memory_manager = `nullptr`,
		IWeightsManager *	weights_manager = `nullptr`
	)

Constructor

Definition at line 148 of file CLFullyConnectedLayerEx.cpp.

  : _memory_group(memory_manager), _weights_manager(weights_manager), _convert_weights(),
    _convert_weights_managed(), _reshape_weights_managed_function(), _flatten_layer(),
    _reshape_weights_function(), _mm_gemm(memory_manager, weights_manager),
    _mm_gemmlowp(memory_manager), _flatten_output(), _converted_weights_output(),
    _reshape_weights_output(), _are_weights_converted(true), _are_weights_reshaped(true),
    _is_fc_after_conv(true), _is_quantized(false), _is_prepared(false), _original_weights(nullptr)
{
}

◆ CLFullyConnectedLayerEx() [2/3]

arm_compute::CLFullyConnectedLayerEx::CLFullyConnectedLayerEx ( const CLFullyConnectedLayerEx & )

delete

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

◆ CLFullyConnectedLayerEx() [3/3]

arm_compute::CLFullyConnectedLayerEx::CLFullyConnectedLayerEx ( CLFullyConnectedLayerEx && )

default

Default move constructor

Member Function Documentation

◆ configure()

void arm_compute::CLFullyConnectedLayerEx::configure	(	const ICLTensor *	input,
		const ICLTensor *	weights,
		const ICLTensor *	biases,
		ICLTensor *	output,
		FullyConnectedLayerInfo	fc_info = `FullyConnectedLayerInfo()`
	)

Set the input and output tensors.

Parameters

[in]	input	Source tensor. Data type supported: QASYMM8/F16/F32.
[in]	weights	Weights tensor. The weights must be 2 dimensional. If this function is called after a Convolution Layer, the (transposed) weights will have as many rows as the product of the first 3 input's dimensions. If it is called after another FullyConnected Layer, the (transposed) weights will have as many rows as the input's first dimension. Data type supported: Same as `input`.
[in]	biases	Bias tensor. Can be nullptr. Data type supported:Same as `input`.
[out]	output	Destination tensor. Its shape should be equal to the output of a matrix multiplication between: The output of im2col on the input and the (transposed) 2D weights, if the function is called after a Convolution Layer The input tensor and the (transposed) 2D weights, if the function is called after another FullyConnected Layer. Data type supported: Same as `input`.
[in]	fc_info	(Optional) Fully connected layer additional info

Definition at line 251 of file CLFullyConnectedLayerEx.cpp.

{
  ARM_COMPUTE_ERROR_ON_NULLPTR(input, weights, output);
 
  // Perform validate step
  ARM_COMPUTE_ERROR_THROW_ON(CLFullyConnectedLayerEx::validate(
    input->info(), weights->info(), biases != nullptr ? biases->info() : nullptr, output->info(),
    fc_info));
 
  _are_weights_converted = true;
  _are_weights_reshaped = fc_info.transpose_weights ? fc_info.are_weights_reshaped : true;
  _is_fc_after_conv = true;
  _is_quantized = is_data_type_quantized_asymmetric(input->info()->data_type());
  _is_prepared = fc_info.retain_internal_weights;
  _original_weights = weights;
 
  if (_weights_manager)
  {
    _weights_manager->manage(weights);
  }
 
  const ICLTensor *weights_to_use = weights;
 
  // 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
 
  // Check if we have a fully connected layer with batches
  const bool is_batched_fc_layer = output->info()->dimension(1) > 1;
  if (is_batched_fc_layer)
  {
    _is_fc_after_conv =
      (TensorShape::num_max_dimensions >= 4) &&
      (std::equal(input->info()->tensor_shape().cbegin() + 3, input->info()->tensor_shape().cend(),
                  output->info()->tensor_shape().cbegin() + 1));
  }
  else
  {
    _is_fc_after_conv = input->info()->num_dimensions() > 1;
  }
 
  // Reshape weights if needed
  if (!_are_weights_reshaped)
  {
    if (_weights_manager && _weights_manager->are_weights_managed(weights))
    {
      _reshape_weights_managed_function.configure(weights);
      weights_to_use = utils::cast::polymorphic_downcast<ICLTensor *>(
        _weights_manager->acquire(weights, &_reshape_weights_managed_function));
    }
    else
    {
      // Reshape the weights
      _reshape_weights_function.configure(weights, &_reshape_weights_output);
      weights_to_use = &_reshape_weights_output;
    }
  }
 
  // Convert weights if needed
  if (_is_fc_after_conv && (input->info()->data_layout() != fc_info.weights_trained_layout))
  {
    if (_weights_manager && _weights_manager->are_weights_managed(weights_to_use))
    {
      _convert_weights_managed.configure(weights_to_use, input->info()->tensor_shape(),
                                         fc_info.weights_trained_layout);
      weights_to_use = utils::cast::polymorphic_downcast<ICLTensor *>(
        _weights_manager->acquire(weights, &_convert_weights_managed));
    }
    else
    {
      // Convert weights
      _convert_weights.configure(weights_to_use, &_converted_weights_output,
                                 input->info()->tensor_shape(), fc_info.weights_trained_layout);
 
      weights_to_use = &_converted_weights_output;
    }
    _are_weights_converted = false;
  }
 
  if (_is_fc_after_conv)
  {
    // Fully Connected layer after a Convolution Layer without batches
    configure_conv_fc(input, weights_to_use, biases, output, fc_info);
  }
  else
  {
    // Fully Connected layer after a Fully Connected Layer without batches
    configure_fc_fc(input, weights_to_use, biases, output, fc_info);
  }
}

References arm_compute::weights_transformations::CLFullyConnectedLayerReshapeWeightsExManaged::configure(), and validate().

◆ operator=() [1/2]

CLFullyConnectedLayerEx & arm_compute::CLFullyConnectedLayerEx::operator= ( CLFullyConnectedLayerEx && )

default

Default move assignment operator

References validate().

◆ operator=() [2/2]

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

delete

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

◆ prepare()

void arm_compute::CLFullyConnectedLayerEx::prepare ( )

override

Definition at line 503 of file CLFullyConnectedLayerEx.cpp.

{
  // DO NOTHING
}

◆ run()

void arm_compute::CLFullyConnectedLayerEx::run ( )

override

Definition at line 430 of file CLFullyConnectedLayerEx.cpp.

{
  if (!_is_prepared)
  {
    if (!_are_weights_reshaped)
      _reshape_weights_output.allocator()->allocate();
    if (!_are_weights_converted)
      _converted_weights_output.allocator()->allocate();
    _is_prepared = true;
  }
 
  {
    if (!_weights_manager)
    {
      ARM_COMPUTE_ERROR_ON(!_original_weights->is_used());
    }
 
    // Pointer to current weights
    const ICLTensor *cur_weights = _original_weights;
    // Reshape of the weights
    if (!_are_weights_reshaped)
    {
      if (_weights_manager && _weights_manager->are_weights_managed(cur_weights))
      {
        _original_weights = utils::cast::polymorphic_downcast<ICLTensor *>(
          _weights_manager->run(cur_weights, &_reshape_weights_managed_function));
      }
      else
      {
        _reshape_weights_function.run();
        cur_weights = &_reshape_weights_output;
      }
    }
 
    // Convert weights if needed
    if (!_are_weights_converted)
    {
      if (_weights_manager && _weights_manager->are_weights_managed(cur_weights))
      {
        _weights_manager->run(cur_weights, &_convert_weights_managed);
      }
      else
      {
        _convert_weights.run();
      }
    }
 
    // Prepare GEMM prepare
    if (!_is_quantized)
    {
      _mm_gemm.prepare();
    }
  }
 
  MemoryGroupResourceScope scope_mg(_memory_group);
 
  // Linearize input if it comes from a convolutional layer
  if (_is_fc_after_conv)
  {
    _flatten_layer.run();
  }
 
  // Run matrix multiply
  if (_is_quantized)
  {
    _mm_gemmlowp.run();
  }
  else
  {
    _mm_gemm.run();
  }
}

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

◆ validate()

Status arm_compute::CLFullyConnectedLayerEx::validate	(	const ITensorInfo *	input,
		const ITensorInfo *	weights,
		const ITensorInfo *	biases,
		const ITensorInfo *	output,
		FullyConnectedLayerInfo	fc_info = `FullyConnectedLayerInfo()`
	)

static

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