arm_compute::NEFullyConnectedReshapingLayer Class Reference

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

#include <NEFullyConnectedReshapingLayer.h>

Collaboration diagram for arm_compute::NEFullyConnectedReshapingLayer:

Public Types
enum class	KernelType { GENERAL , PREPROCESSED_WEIGHTS }

Public Member Functions
	NEFullyConnectedReshapingLayer (std::shared_ptr< IMemoryManager > memory_manager=nullptr)
void	configure (const arm_compute::ITensor *input, const arm_compute::ITensor *weights, const arm_compute::ITensor *biases, arm_compute::ITensor *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 NEFullyConnectedReshapingLayer.h.

Member Enumeration Documentation

KernelType

enum class arm_compute::NEFullyConnectedReshapingLayer::KernelType

strong

Enumerator
GENERAL
PREPROCESSED_WEIGHTS

Definition at line 38 of file NEFullyConnectedReshapingLayer.h.

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

Constructor & Destructor Documentation

NEFullyConnectedReshapingLayer()

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

inline

Definition at line 45 of file NEFullyConnectedReshapingLayer.h.

    : _memory_manager{memory_manager}, _input(nullptr), _weights(nullptr), _biases(nullptr),
      _output(nullptr), _neon_buffer{}, _neon_fc{nullptr}, _neon_reshape{}, _needs_reshape(false)
  {
    // DO NOTHING
  }

Member Function Documentation

configure()

void NEFullyConnectedReshapingLayer::configure	(	const arm_compute::ITensor *	input,
		const arm_compute::ITensor *	weights,
		const arm_compute::ITensor *	biases,
		arm_compute::ITensor *	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.
[in]	kernel_type	The kernel type for actual FullyConnected layer

Returns

N/A

Definition at line 27 of file NEFullyConnectedReshapingLayer.cpp.

{
  _input = input;
  _weights = weights;
  _biases = biases;
  _output = output;
  _needs_reshape = needs_reshape;
 
  const ITensor *input_to_use = input;
  if (_needs_reshape)
  {
    // reshape
    auto_init_if_empty(*_neon_buffer.info(),
                       _input->info()->clone()->set_tensor_shape(reshape).set_data_layout(
                         _input->info()->data_layout()));
    _neon_reshape.configure(_input, &_neon_buffer);
    input_to_use = &_neon_buffer;
  }
 
  _neon_fc = [&]() {
    if (kernel_type == KernelType::GENERAL)
    {
      auto fc = new arm_compute::NEFullyConnectedLayerEx{_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::NEFullyConnectedHybridLayer{_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::NEFullyConnectedLayer{_memory_manager};
        fc->configure(input_to_use, _weights, _biases, _output);
        return std::unique_ptr<arm_compute::IFunction>(fc);
      }
    }
    else
    {
      throw std::runtime_error("NEFullyConnectedReshapingLayer: Unsupported kernel type");
    }
  }();
 
  // NOTE _neon_buffer is inaccessible from outside, and thus it is safe to invoke allocate here.
  if (_needs_reshape)
  {
    _neon_buffer.allocator()->allocate();
  }
}

References GENERAL, and PREPROCESSED_WEIGHTS.

prepare()

void NEFullyConnectedReshapingLayer::prepare ( void  )

override

Prepare the operation.

Returns

N/A

Definition at line 103 of file NEFullyConnectedReshapingLayer.cpp.

{ _neon_fc->prepare(); }

run()

void NEFullyConnectedReshapingLayer::run ( void  )

override

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

Returns

N/A

Definition at line 95 of file NEFullyConnectedReshapingLayer.cpp.

{
  if (_needs_reshape)
    _neon_reshape.run();
 
  _neon_fc->run();
}

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

---

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

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