onert::backend::cpu::ops::ConcatLayer Class Reference

#include <ConcatLayer.h>

Collaboration diagram for onert::backend::cpu::ops::ConcatLayer:

Public Member Functions
	ConcatLayer ()
template<typename T >
void	concatenationGeneral ()
void	concatenationQuant8 ()
void	configure (const std::vector< const IPortableTensor * > &inputs, int32_t axis, IPortableTensor *output)
void	run () override
Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default
virtual void	prepare ()

Detailed Description

Definition at line 33 of file ConcatLayer.h.

Constructor & Destructor Documentation

ConcatLayer()

onert::backend::cpu::ops::ConcatLayer::ConcatLayer

(

)

Definition at line 32 of file ConcatLayer.cc.

                         : _inputs(), _output(nullptr), _axis(0)
{
  // DO NOTHING
}

Member Function Documentation

concatenationGeneral()

template<typename T >

void onert::backend::cpu::ops::ConcatLayer::concatenationGeneral

(

)

Definition at line 37 of file ConcatLayer.cc.

{
  uint32_t num_inputs = _inputs.size();
 
  nnfw::cker::ConcatenationParams op_params;
  op_params.axis = _axis;
  op_params.inputs_count = num_inputs;
 
  std::vector<nnfw::cker::Shape *> inputDimsPtr;
  std::vector<nnfw::cker::Shape> inputDims;
  inputDimsPtr.reserve(num_inputs);
  inputDims.reserve(num_inputs);
 
  for (uint32_t i = 0; i < num_inputs; i++)
  {
    inputDims.push_back(getShape(_inputs[i]));
    inputDimsPtr.push_back(&inputDims[i]);
  }
 
  std::vector<const T *> inputDataPtrs;
 
  for (const auto input : _inputs)
  {
    inputDataPtrs.emplace_back(getBuffer<T>(input));
  }
 
  nnfw::cker::Concatenation<T>(op_params, inputDimsPtr.data(), inputDataPtrs.data(),
                               getShape(_output), getBuffer<T>(_output));
}

References nnfw::cker::ConcatenationParams::axis, onert::backend::cpu::ops::getShape(), and nnfw::cker::ConcatenationParams::inputs_count.

concatenationQuant8()

void onert::backend::cpu::ops::ConcatLayer::concatenationQuant8

(

)

Definition at line 66 of file ConcatLayer.cc.

{
  uint32_t num_inputs = _inputs.size();
 
  std::vector<int32_t> input_zeropoints(num_inputs);
  std::vector<float> input_scales(num_inputs);
  for (uint32_t i = 0; i < num_inputs; i++)
  {
    input_zeropoints[i] = _inputs[i]->data_zero_point();
    input_scales[i] = _inputs[i]->data_scale();
  }
 
  nnfw::cker::ConcatenationParams op_params;
  op_params.axis = _axis;
  op_params.inputs_count = num_inputs;
  op_params.input_zeropoint = input_zeropoints.data();
  op_params.input_scale = input_scales.data();
  op_params.output_zeropoint = _output->data_zero_point();
  op_params.output_scale = _output->data_scale();
 
  std::vector<nnfw::cker::Shape *> inputDimsPtr;
  std::vector<nnfw::cker::Shape> inputDims;
  inputDimsPtr.reserve(num_inputs);
  inputDims.reserve(num_inputs);
  for (uint32_t i = 0; i < num_inputs; i++)
  {
    inputDims.push_back(getShape(_inputs[i]));
    inputDimsPtr.push_back(&inputDims[i]);
  }
 
  std::vector<const uint8_t *> inputDataPtrs;
  for (const auto input : _inputs)
  {
    inputDataPtrs.emplace_back(getBuffer<uint8_t>(input));
  }
 
  nnfw::cker::ConcatenationWithScaling(op_params, inputDimsPtr.data(), inputDataPtrs.data(),
                                       getShape(_output), getBuffer<uint8_t>(_output));
}

References nnfw::cker::ConcatenationParams::axis, nnfw::cker::ConcatenationWithScaling(), onert::backend::IPortableTensor::data_scale(), onert::backend::IPortableTensor::data_zero_point(), onert::backend::cpu::ops::getShape(), nnfw::cker::ConcatenationParams::input_scale, nnfw::cker::ConcatenationParams::input_zeropoint, nnfw::cker::ConcatenationParams::inputs_count, nnfw::cker::ConcatenationParams::output_scale, and nnfw::cker::ConcatenationParams::output_zeropoint.

Referenced by run().

configure()

void onert::backend::cpu::ops::ConcatLayer::configure	(	const std::vector< const IPortableTensor * > &	inputs,
		int32_t	axis,
		IPortableTensor *	output
	)

Definition at line 106 of file ConcatLayer.cc.

{
  assert(inputs.size() > 0);
  assert(output != nullptr);
 
  _inputs = inputs;
  _axis = axis;
  _output = output;
}

run()

void onert::backend::cpu::ops::ConcatLayer::run ( )

overridevirtual

Implements onert::exec::IFunction.

Definition at line 117 of file ConcatLayer.cc.

{
  switch (_output->data_type())
  {
    case OperandType::FLOAT32:
      concatenationGeneral<float>();
      break;
    case OperandType::QUANT_UINT8_ASYMM:
      concatenationQuant8();
      break;
    case OperandType::QUANT_INT8_ASYMM:
      concatenationGeneral<int8_t>();
      break;
    case OperandType::INT32:
      concatenationGeneral<int32_t>();
      break;
    case OperandType::INT64:
      concatenationGeneral<int64_t>();
      break;
    default:
      throw std::runtime_error("Concat: unsupported data type");
  }
}

References concatenationQuant8(), and onert::backend::IPortableTensor::data_type().

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

---

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

• runtime/onert/backend/cpu/ops/ConcatLayer.h
• runtime/onert/backend/cpu/ops/ConcatLayer.cc