#include <DepthwiseConv2D.h>

Collaboration diagram for luci_interpreter::kernels::DepthwiseConv2D:

[legend]

Public Member Functions
	DepthwiseConv2D (const Tensor input, const Tensor filter, const Tensor bias, Tensor output, Tensor *scratchpad, const DepthwiseConv2DParams &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< DepthwiseConv2DParams >
const DepthwiseConv2DParams &	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< DepthwiseConv2DParams >
	KernelWithParams (std::vector< const Tensor * > inputs, std::vector< Tensor * > outputs, const DepthwiseConv2DParams &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< DepthwiseConv2DParams >
const DepthwiseConv2DParams	_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 DepthwiseConv2D.h.

Constructor & Destructor Documentation

◆ DepthwiseConv2D()

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

Definition at line 30 of file DepthwiseConv2D.cpp.

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

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

Member Function Documentation

◆ bias()

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

inline

Definition at line 36 of file DepthwiseConv2D.h.

36{ return _inputs[2]; }

luci_interpreter::Kernel::_inputs

const std::vector< const Tensor * > _inputs

Definition Kernel.h:52

References luci_interpreter::Kernel::_inputs.

Referenced by configure(), and DepthwiseConv2D().

◆ configure()

void luci_interpreter::kernels::DepthwiseConv2D::configure ( )

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 37 of file DepthwiseConv2D.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
  // (5) | int16 int8   int64 int16  | quantized per channel 16x8
  //
  // 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(filter()->shape().num_dims() == 4);
    LUCI_INTERPRETER_CHECK(static_cast<uint32_t>(filter()->shape().dim(3)) ==
                           filter()->scales().size());
    for (auto zerop : filter()->zero_points())
    {
      LUCI_INTERPRETER_CHECK(zerop == 0);
    }
    LUCI_INTERPRETER_CHECK(bias() == nullptr || bias()->element_type() == DataType::S32);
  }
  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 DepthwiseConv2D(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);
  // Filter format: [1, H, W, O].
  LUCI_INTERPRETER_CHECK(filter_shape.dim(0) == 1);
  const int32_t filter_height = filter_shape.dim(1);
  const int32_t filter_width = filter_shape.dim(2);
  const int32_t channels_out = filter_shape.dim(3);
 
  LUCI_INTERPRETER_CHECK(bias() == nullptr || (bias()->shape().num_dims() == 1 &&
                                               bias()->shape().dim(0) == channels_out));
 
  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, channels_out});
 
  tflite::DepthwiseParams params{};
 
  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, params, input()->element_type(),
                                              getTensorShape(input()), getTensorShape(filter()),
                                              getTensorShape(output()));
}

◆ execute()

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

overridevirtual

Implements luci_interpreter::Kernel.

Definition at line 123 of file DepthwiseConv2D.cpp.

{
  switch (input()->element_type())
  {
    case DataType::FLOAT32:
      if (filter()->element_type() == DataType::FLOAT32)
      {
        evalFloat();
        break;
      }
      throw std::runtime_error("luci-intp DepthwiseConv2D(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(3)));
        evalQuantizedPerChannel();
      }
      break;
    case DataType::S8:
      evalQuantizedS8PerChannel();
      break;
    case DataType::S16:
      evalQuantizedS16();
      break;
    default:
      throw std::runtime_error("luci-intp DepthwiseConv2D(3) Unsupported type.");
  }
}