#include <Concatenation.h>

Collaboration diagram for luci_interpreter::kernels::Concatenation:

[legend]

Public Member Functions
	Concatenation (std::vector< const Tensor * > inputs, Tensor *output, const ConcatenationParams &params)

const Tensor *	input (int index) const

Tensor *	output () const

void	configure () override

void	execute () const override

Public Member Functions inherited from luci_interpreter::KernelWithParams< ConcatenationParams >
const ConcatenationParams &	params () const

Public Member Functions inherited from luci_interpreter::Kernel
virtual	~Kernel ()=default

const std::vector< const Tensor * > &	getInputTensors () const

const std::vector< Tensor * > &	getOutputTensors () const

Additional Inherited Members
Protected Member Functions inherited from luci_interpreter::KernelWithParams< ConcatenationParams >
	KernelWithParams (std::vector< const Tensor * > inputs, std::vector< Tensor * > outputs, const ConcatenationParams &params)

Protected Member Functions inherited from luci_interpreter::Kernel
	Kernel (std::vector< const Tensor * > inputs, std::vector< Tensor * > outputs)

Protected Attributes inherited from luci_interpreter::KernelWithParams< ConcatenationParams >
const ConcatenationParams	_params

Protected Attributes inherited from luci_interpreter::Kernel
const std::vector< const Tensor * >	_inputs

const std::vector< Tensor * >	_outputs

Detailed Description

Definition at line 28 of file Concatenation.h.

Constructor & Destructor Documentation

◆ Concatenation()

luci_interpreter::kernels::Concatenation::Concatenation	(	std::vector< const Tensor * >	inputs,
		Tensor *	output,
		const ConcatenationParams &	params
	)

Definition at line 30 of file Concatenation.cpp.

  : KernelWithParams<ConcatenationParams>(std::move(inputs), {output}, params)
{
}

References output().

Member Function Documentation

◆ configure()

void luci_interpreter::kernels::Concatenation::configure ( )

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 36 of file Concatenation.cpp.

{
  const int num_inputs = _inputs.size();
  LUCI_INTERPRETER_CHECK(num_inputs > 0);
  const Tensor *t0 = _inputs[0];
 
  // TODO: Support concat with fused activation function
  LUCI_INTERPRETER_CHECK(params().activation == luci::FusedActFunc::NONE);
 
  int axis = _params.axis;
  if (axis < 0)
    axis += t0->shape().num_dims();
  LUCI_INTERPRETER_CHECK(axis >= 0 && axis < t0->shape().num_dims());
 
  int32_t sum_axis = t0->shape().dim(axis);
  for (int i = 1; i < num_inputs; ++i)
  {
    const Tensor *tensor = _inputs[i];
    LUCI_INTERPRETER_CHECK(tensor->element_type() == t0->element_type());
    LUCI_INTERPRETER_CHECK(tensor->shape().num_dims() == t0->shape().num_dims());
    for (int d = 0; d < t0->shape().num_dims(); ++d)
    {
      if (d == axis)
      {
        sum_axis += tensor->shape().dim(axis);
      }
      else
      {
        LUCI_INTERPRETER_CHECK(tensor->shape().dim(d) == t0->shape().dim(d));
      }
    }
  }
 
  Shape output_shape = t0->shape();
  output_shape.dim(axis) = sum_axis;
 
  // If input tensors are INT8 type then quantization parameters of all input tensors and the output
  // should be the same
  for (auto current_tensor : _inputs)
  {
    if (current_tensor->element_type() == DataType::S8)
    {
      LUCI_INTERPRETER_CHECK(current_tensor->quantized_dimension() ==
                             output()->quantized_dimension());
 
      LUCI_INTERPRETER_CHECK(current_tensor->zero_points().size() ==
                             current_tensor->scales().size());
      LUCI_INTERPRETER_CHECK(current_tensor->zero_points() == output()->zero_points());
      LUCI_INTERPRETER_CHECK(current_tensor->scales() == output()->scales());
    }
  }
  output()->resize(output_shape);
}

References luci_interpreter::Kernel::_inputs, luci_interpreter::KernelWithParams< ConcatenationParams >::_params, luci_interpreter::ConcatenationParams::axis, LUCI_INTERPRETER_CHECK, luci::must_cast(), luci::NONE, output(), output_shape, luci_interpreter::KernelWithParams< ConcatenationParams >::params(), and luci_interpreter::Tensor::resize().

◆ execute()

void luci_interpreter::kernels::Concatenation::execute ( ) const

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 90 of file Concatenation.cpp.

{
  switch (_inputs[0]->element_type())
  {
    case DataType::FLOAT32:
      evalGeneric<float>();
      break;
    case DataType::U8:
      evalQuantized();
      break;
    case DataType::S8:
      evalGeneric<int8_t>();
      break;
    case DataType::S32:
      evalGeneric<int32_t>();
      break;
    case DataType::S64:
      evalGeneric<int64_t>();
      break;
    default:
      throw std::runtime_error("luci-intp Concatenation Unsupported type.");
  }
}