luci_interpreter::kernels::Conv2D Class Reference

#include <Conv2D.h>

Collaboration diagram for luci_interpreter::kernels::Conv2D:

Public Member Functions
	Conv2D (const Tensor *input, const Tensor *filter, const Tensor *bias, Tensor *output, Tensor *scratchpad, const Conv2DParams &params)
const Tensor *	input () const
const Tensor *	filter () const
const Tensor *	bias () const
Tensor *	output () const
void	configure () override
void	execute () const override
Public Member Functions inherited from luci_interpreter::KernelWithParams< Conv2DParams >
const Conv2DParams &	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< Conv2DParams >
	KernelWithParams (std::vector< const Tensor * > inputs, std::vector< Tensor * > outputs, const Conv2DParams &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< Conv2DParams >
const Conv2DParams	_params
Protected Attributes inherited from luci_interpreter::Kernel
const std::vector< const Tensor * >	_inputs
const std::vector< Tensor * >	_outputs

Detailed Description

Definition at line 30 of file Conv2D.h.

Constructor & Destructor Documentation

Conv2D()

luci_interpreter::kernels::Conv2D::Conv2D	(	const Tensor *	input,
		const Tensor *	filter,
		const Tensor *	bias,
		Tensor *	output,
		Tensor *	scratchpad,
		const Conv2DParams &	params
	)

Definition at line 32 of file Conv2D.cpp.

  : KernelWithParams<Conv2DParams>({input, filter, bias}, {output, scratchpad}, params)
{
}

References bias(), filter(), and input().

Member Function Documentation

bias()

const Tensor * luci_interpreter::kernels::Conv2D::bias ( ) const

inline

Definition at line 38 of file Conv2D.h.

{ return _inputs[2]; }

References luci_interpreter::Kernel::_inputs.

Referenced by configure(), and Conv2D().

configure()

void luci_interpreter::kernels::Conv2D::configure ( )

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 38 of file Conv2D.cpp.

{
  // TensorFlow Lite (as of v2.2.0) supports the following combinations of types:
  //     | input filter bias  output |
  // ----+---------------------------+
  // (1) | float float  float float  |
  // (2) | float int8   float float  | hybrid
  // (3) | uint8 uint8  int32 uint8  | quantized
  // (4) | int8  int8   int32 int8   | quantized per channel
  //
  // We only support (1), (3) and (4) for now, and additionally the following:
  //     | input filter bias  output |
  // ----+---------------------------+
  // (5) | int16 int16  int64 int16  |
  //
  if (input()->element_type() == DataType::FLOAT32 && filter()->element_type() == DataType::FLOAT32)
  {
    LUCI_INTERPRETER_CHECK(bias() == nullptr || bias()->element_type() == DataType::FLOAT32);
  }
  else if (input()->element_type() == DataType::U8 && filter()->element_type() == DataType::U8)
  {
    LUCI_INTERPRETER_CHECK(bias() == nullptr || bias()->element_type() == DataType::S32);
  }
  else if (input()->element_type() == DataType::S8 && filter()->element_type() == DataType::S8)
  {
    LUCI_INTERPRETER_CHECK(bias() == nullptr || bias()->element_type() == DataType::S32);
    LUCI_INTERPRETER_CHECK(filter()->shape().num_dims() == 4);
    LUCI_INTERPRETER_CHECK(filter()->scales().size() ==
                           static_cast<size_t>(filter()->shape().dim(0)));
    for (auto zerop : filter()->zero_points())
    {
      LUCI_INTERPRETER_CHECK(zerop == 0);
    }
  }
  else if (input()->element_type() == DataType::S16 && filter()->element_type() == DataType::S16)
  {
    LUCI_INTERPRETER_CHECK(bias() == nullptr || bias()->element_type() == DataType::S64);
  }
  else
  {
    throw std::runtime_error("luci-intp Conv2D(1) Unsupported type.");
  }
  LUCI_INTERPRETER_CHECK(output()->element_type() == input()->element_type());
 
  const Shape &input_shape = input()->shape();
  const Shape &filter_shape = filter()->shape();
  LUCI_INTERPRETER_CHECK(input_shape.num_dims() == 4 && filter_shape.num_dims() == 4);
 
  const int32_t batches = input_shape.dim(0);
  const int32_t input_height = input_shape.dim(1);
  const int32_t input_width = input_shape.dim(2);
  const int32_t output_depth = filter_shape.dim(0);
  const int32_t filter_height = filter_shape.dim(1);
  const int32_t filter_width = filter_shape.dim(2);
  LUCI_INTERPRETER_CHECK(filter_shape.dim(3) == input_shape.dim(3));
 
  LUCI_INTERPRETER_CHECK(bias() == nullptr || (bias()->shape().num_dims() == 1 &&
                                               bias()->shape().dim(0) == output_depth));
 
  const int32_t output_height =
    computeOutputSize(_params.padding, input_height, filter_height, _params.stride_height,
                      _params.dilation_height_factor);
  const int32_t output_width =
    computeOutputSize(_params.padding, input_width, filter_width, _params.stride_width,
                      _params.dilation_width_factor);
 
  _padding_height = computePadding(_params.stride_height, _params.dilation_height_factor,
                                   input_height, filter_height, output_height);
  _padding_width = computePadding(_params.stride_width, _params.dilation_width_factor, input_width,
                                  filter_width, output_width);
 
  output()->resize({batches, output_height, output_width, output_depth});
 
  // Allocate tensor for scratchpad, if needed.
  tflite::ConvParams params{};
  params.padding_values.height = _padding_height;
  params.padding_values.width = _padding_width;
  params.stride_height = _params.stride_height;
  params.stride_width = _params.stride_width;
  params.dilation_height_factor = _params.dilation_height_factor;
  params.dilation_width_factor = _params.dilation_width_factor;
  auto scratchpad = getOutputTensors()[1];
  luci_interpreter_pal::SetupScratchpadTensor(scratchpad, input()->element_type(), params,
                                              getTensorShape(input()), getTensorShape(filter()),
                                              getTensorShape(output()));
 
  switch (_params.activation)
  {
    case Activation::NONE:
    case Activation::RELU:
    case Activation::RELU6:
    case Activation::RELU_N1_TO_1:
      break;
    default:
      throw std::runtime_error("Unsupported fused activation");
  }
}

References luci_interpreter::KernelWithParams< Conv2DParams >::_params, luci_interpreter::Conv2DParams::activation, bias(), luci_interpreter::kernels::computeOutputSize(), luci_interpreter::kernels::computePadding(), luci_interpreter::Conv2DParams::dilation_height_factor, luci_interpreter::Conv2DParams::dilation_width_factor, luci_interpreter::Shape::dim(), filter(), luci_interpreter::Kernel::getOutputTensors(), luci_interpreter::kernels::getTensorShape(), input(), LUCI_INTERPRETER_CHECK, luci_interpreter::Shape::num_dims(), output(), luci_interpreter::Conv2DParams::padding, luci_interpreter::KernelWithParams< Conv2DParams >::params(), luci_interpreter::Tensor::resize(), luci_interpreter::Tensor::shape(), size, luci_interpreter::Conv2DParams::stride_height, luci_interpreter::Conv2DParams::stride_width, and luci_interpreter::Tensor::zero_points().

execute()

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

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 136 of file Conv2D.cpp.

{
  switch (input()->element_type())
  {
    case DataType::FLOAT32:
      if (filter()->element_type() == DataType::FLOAT32)
      {
        evalFloat();
        break;
      }
      throw std::runtime_error("luci-intp Conv2D(2) Unsupported type.");
    case DataType::U8:
      if (filter()->scales().size() == 1)
      {
        evalQuantized();
      }
      else if (filter()->scales().size() > 1)
      {
        LUCI_INTERPRETER_CHECK(filter()->shape().num_dims() == 4);
        LUCI_INTERPRETER_CHECK(filter()->scales().size() ==
                               static_cast<size_t>(filter()->shape().dim(0)));
        evalQuantizedPerChannel();
      }
      break;
    case DataType::S8:
      evalQuantizedS8PerChannel();
      break;
    case DataType::S16:
      evalQuantizedS16();
      break;
    default:
      throw std::runtime_error("luci-intp Conv2D(3) Unsupported type.");
  }
}

References filter(), input(), LUCI_INTERPRETER_CHECK, and size.

filter()

const Tensor * luci_interpreter::kernels::Conv2D::filter ( ) const

inline

Definition at line 37 of file Conv2D.h.

{ return _inputs[1]; }

References luci_interpreter::Kernel::_inputs.

Referenced by configure(), Conv2D(), and execute().

input()

const Tensor * luci_interpreter::kernels::Conv2D::input ( ) const

inline

Definition at line 36 of file Conv2D.h.

{ return _inputs[0]; }

References luci_interpreter::Kernel::_inputs.

Referenced by configure(), Conv2D(), and execute().

output()

Tensor * luci_interpreter::kernels::Conv2D::output ( ) const

inline

Definition at line 39 of file Conv2D.h.

{ return _outputs[0]; }

References luci_interpreter::Kernel::_outputs.

Referenced by configure().

---

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

• compiler/luci-interpreter/src/kernels/Conv2D.h
• compiler/luci-interpreter/src/kernels/Conv2D.cpp