arm_compute::CLFullyConnectedReshapingLayer Class Reference

Class to run FullyConnected Layer after reshaping input tensor. More...

#include <CLFullyConnectedReshapingLayer.h>

Collaboration diagram for arm_compute::CLFullyConnectedReshapingLayer:

Public Types
enum class	KernelType { GENERAL , PREPROCESSED_WEIGHTS }

Public Member Functions
	CLFullyConnectedReshapingLayer (std::shared_ptr< IMemoryManager > memory_manager=nullptr)
void	configure (const arm_compute::ICLTensor *input, const arm_compute::ICLTensor *weights, const arm_compute::ICLTensor *biases, arm_compute::ICLTensor *output, bool needs_reshape, const arm_compute::TensorShape &reshape, KernelType kernel_type)
	Configure the layer.
void	run (void) override
	Run the operation. Must be called after configure().
void	prepare (void) override
	Prepare the operation.

Detailed Description

Class to run FullyConnected Layer after reshaping input tensor.

Definition at line 35 of file CLFullyConnectedReshapingLayer.h.

Member Enumeration Documentation

KernelType

enum class arm_compute::CLFullyConnectedReshapingLayer::KernelType

strong

Enumerator
GENERAL
PREPROCESSED_WEIGHTS

Definition at line 38 of file CLFullyConnectedReshapingLayer.h.

  {
    GENERAL,             //< General FC
    PREPROCESSED_WEIGHTS //< Weights are constants so it can be preprocessed
  };

Constructor & Destructor Documentation

CLFullyConnectedReshapingLayer()

arm_compute::CLFullyConnectedReshapingLayer::CLFullyConnectedReshapingLayer ( std::shared_ptr< IMemoryManager >  memory_manager = nullptr )

inline

Definition at line 45 of file CLFullyConnectedReshapingLayer.h.

    : _input(nullptr), _weights(nullptr), _biases(nullptr), _output(nullptr), _cl_buffer{},
      _memory_manager{memory_manager}, _cl_fc{nullptr}, _cl_reshape{}, _needs_reshape(false)
  {
    // DO NOTHING
  }

Member Function Documentation

configure()

void CLFullyConnectedReshapingLayer::configure	(	const arm_compute::ICLTensor *	input,
		const arm_compute::ICLTensor *	weights,
		const arm_compute::ICLTensor *	biases,
		arm_compute::ICLTensor *	output,
		bool	needs_reshape,
		const arm_compute::TensorShape &	reshape,
		KernelType	kernel_type
	)

Configure the layer.

Parameters

[in]	input	The source tensor
[in]	weights	The tensor that is filled with weight values
[in]	biases	The tensor that is filled with biase values
[in]	output	The destination tensor
[in]	needs_reshape	Whether it needs to be reshaped or not
[in]	reshape	The tensor shape to be reshaped. Only valid when needs_reshape is true.

Returns

N/A

Definition at line 26 of file CLFullyConnectedReshapingLayer.cpp.

{
  _input = input;
  _weights = weights;
  _biases = biases;
  _output = output;
  _needs_reshape = needs_reshape;
 
  const ICLTensor *input_to_use = input;
  if (_needs_reshape)
  {
    // reshape
    auto_init_if_empty(*_cl_buffer.info(),
                       _input->info()->clone()->set_tensor_shape(reshape).set_data_layout(
                         _input->info()->data_layout()));
    _cl_reshape.configure(_input, &_cl_buffer);
    input_to_use = &_cl_buffer;
  }
 
  _cl_fc = [&]() {
    if (kernel_type == KernelType::GENERAL)
    {
      auto fc = new arm_compute::CLFullyConnectedLayerEx{_memory_manager};
      fc->configure(input_to_use, _weights, _biases, _output);
      return std::unique_ptr<arm_compute::IFunction>(fc);
    }
    else if (kernel_type == KernelType::PREPROCESSED_WEIGHTS)
    {
      bool is_hybrid = (input->info()->data_type() == DataType::F32 ||
                        input->info()->data_type() == DataType::F16) &&
                       (weights->info()->data_type() == DataType::QSYMM8 ||
                        weights->info()->data_type() == DataType::QASYMM8_SIGNED);
 
      if (is_hybrid)
      {
        auto fc = new arm_compute::CLFullyConnectedHybridLayer{_memory_manager};
        ITensorInfo *weights_info = const_cast<ITensorInfo *>(_weights->info());
        const auto orgin_weights_data_type = weights_info->data_type();
        weights_info->set_data_type(DataType::QASYMM8_SIGNED);
        fc->configure(input_to_use, _weights, _biases, _output);
        weights_info->set_data_type(orgin_weights_data_type);
        return std::unique_ptr<arm_compute::IFunction>(fc);
      }
      else
      {
        auto fc = new arm_compute::CLFullyConnectedLayer{_memory_manager};
        fc->configure(input_to_use, _weights, _biases, _output);
        return std::unique_ptr<arm_compute::IFunction>(fc);
      }
    }
    else
    {
      throw std::runtime_error("CLFullyConnectedReshapingLayer: Unsupported kernel type");
    }
  }();
 
  if (_needs_reshape)
  {
    // NOTE _cl_buffer is inaccessible from outside, and thus it is safe to invoke allocate here.
    _cl_buffer.allocator()->allocate();
  }
}

References GENERAL, and PREPROCESSED_WEIGHTS.

prepare()

void CLFullyConnectedReshapingLayer::prepare ( void  )

override

Prepare the operation.

Returns

N/A

Definition at line 102 of file CLFullyConnectedReshapingLayer.cpp.

{ _cl_fc->prepare(); }

run()

void CLFullyConnectedReshapingLayer::run ( void  )

override

Run the operation. Must be called after configure().

Returns

N/A

Definition at line 94 of file CLFullyConnectedReshapingLayer.cpp.

{
  if (_needs_reshape)
    _cl_reshape.run();
 
  _cl_fc->run();
}

---

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

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