#include <DepthwiseConvolutionLayer.h>

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

[legend]

Public Member Functions
	DepthwiseConvolutionLayer ()=default

void	convFloat32 ()

void	convQ8uPerTensor ()

void	convQ8uPerChannel ()

void	convQ8i ()

void	convQ8iHybridPerChannel ()

void	configure (const IPortableTensor input, const IPortableTensor kernel, const IPortableTensor bias, const uint32_t paddingLeft, const uint32_t paddingRight, const uint32_t paddingTop, const uint32_t paddingBottom, const uint32_t strideW, const uint32_t strideH, const uint32_t multiplier, const uint32_t dilationWidth, const uint32_t dilationHeight, const ir::Activation activation, IPortableTensor output, const std::shared_ptr< ExternalContext > &external_context)

void	run () override

Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default

virtual void	prepare ()

Protected Attributes
const IPortableTensor *	_input {nullptr}

const IPortableTensor *	_kernel {nullptr}

const IPortableTensor *	_bias {nullptr}

IPortableTensor *	_output {nullptr}

uint32_t	_paddingLeft {0}

uint32_t	_paddingTop {0}

uint32_t	_paddingRight {0}

uint32_t	_paddingBottom {0}

uint32_t	_strideWidth {0}

uint32_t	_strideHeight {0}

uint32_t	_multiplier {0}

uint32_t	_dilationWidth {1}

uint32_t	_dilationHeight {1}

ir::Activation	_activation {ir::Activation::NONE}

bool	_use_padded_filter {false}

std::unique_ptr< Tensor >	_padded_filter {nullptr}

std::unique_ptr< Tensor >	_filter_buffers {nullptr}

Detailed Description

Definition at line 36 of file DepthwiseConvolutionLayer.h.

Constructor & Destructor Documentation

◆ DepthwiseConvolutionLayer()

onert::backend::cpu::ops::DepthwiseConvolutionLayer::DepthwiseConvolutionLayer ( )

default

Member Function Documentation

◆ configure()

void onert::backend::cpu::ops::DepthwiseConvolutionLayer::configure	(	const IPortableTensor *	input,
		const IPortableTensor *	kernel,
		const IPortableTensor *	bias,
		const uint32_t	paddingLeft,
		const uint32_t	paddingRight,
		const uint32_t	paddingTop,
		const uint32_t	paddingBottom,
		const uint32_t	strideW,
		const uint32_t	strideH,
		const uint32_t	multiplier,
		const uint32_t	dilationWidth,
		const uint32_t	dilationHeight,
		const ir::Activation	activation,
		IPortableTensor *	output,
		const std::shared_ptr< ExternalContext > &	external_context
	)

Definition at line 286 of file DepthwiseConvolutionLayer.cc.

{
  _input = input;
  _kernel = kernel;
  _bias = bias;
  _paddingLeft = paddingLeft;
  _paddingRight = paddingRight;
  _paddingTop = paddingTop;
  _paddingBottom = paddingBottom;
  _strideWidth = strideWidth;
  _strideHeight = strideHeight;
  _multiplier = multiplier;
  _dilationWidth = dilationWidth;
  _dilationHeight = dilationHeight;
  _activation = activation;
  _output = output;
  _external_context = external_context;
  _is_hybrid = _input->data_type() == OperandType::FLOAT32 &&
               _kernel->data_type() == OperandType::QUANT_INT8_SYMM;
 
  if (_is_hybrid)
  {
    ensureQ8iHybridPerChannel();
    prepareQ8iHybridPerChannel();
    _prepared = true;
  }
  else if (_input->data_type() == OperandType::FLOAT32)
  {
    prepareF32();
  }
  else if (_input->data_type() == OperandType::QUANT_INT8_ASYMM)
  {
    if (_kernel->is_constant() && !_input->is_dynamic() && !_output->is_dynamic())
    {
      prepareQ8i();
      _prepared = true;
    }
  }
  else if (_input->data_type() == OperandType::QUANT_UINT8_ASYMM && _kernel->is_constant() &&
           !_input->is_dynamic() && !_output->is_dynamic())
  {
    const bool per_channel_quantized = _kernel->data_scales().size() > 1;
    if (per_channel_quantized)
    {
      prepareQ8uPerChannel();
      _prepared = true;
    }
  }
}

References _activation, _bias, _dilationHeight, _dilationWidth, _input, _kernel, _multiplier, _output, _paddingBottom, _paddingLeft, _paddingRight, _paddingTop, _strideHeight, _strideWidth, onert::backend::IPortableTensor::data_scales(), onert::backend::IPortableTensor::data_type(), onert::backend::IPortableTensor::is_constant(), and onert::backend::IPortableTensor::is_dynamic().

◆ convFloat32()

void onert::backend::cpu::ops::DepthwiseConvolutionLayer::convFloat32 ( )

Definition at line 68 of file DepthwiseConvolutionLayer.cc.

{
  float output_activation_min = 0, output_activation_max = 0;
  CalculateActivationRange(_activation, &output_activation_min, &output_activation_max);
 
  nnfw::cker::DepthwiseConvParams op_params;
  op_params.stride_width = _strideWidth;
  op_params.stride_height = _strideHeight;
  op_params.dilation_width_factor = _dilationWidth;
  op_params.dilation_height_factor = _dilationHeight;
  op_params.padding_values.width = _paddingLeft;
  op_params.padding_values.height = _paddingTop;
  op_params.depth_multiplier = _multiplier;
  op_params.float_activation_min = output_activation_min;
  op_params.float_activation_max = output_activation_max;
 
  // Since DepthwiseConvOp does not support dilation and different W/H stride yet,
  // it uses the existing kernel in this case.
  if (_dilationWidth == 1 && _dilationHeight == 1 && _strideWidth == _strideHeight)
  {
    nnfw::cker::DepthwiseConvOp(op_params, getShape(_input), getBuffer<float>(_input),
                                getShape(_kernel), getBuffer<float>(_kernel), getShape(_bias),
                                getBuffer<float>(_bias), getBuffer<float>(_padded_filter.get()),
                                _use_padded_filter, getBuffer<float>(_filter_buffers.get()),
                                getShape(_output), getBuffer<float>(_output));
  }
  else
  {
    nnfw::cker::DepthwiseConv<float, float>(
      op_params, getShape(_input), getBuffer<float>(_input), getShape(_kernel),
      getBuffer<float>(_kernel), getShape(_bias), getBuffer<float>(_bias), getShape(_output),
      getBuffer<float>(_output), _external_context->ruy_context());
  }
}

Referenced by run().

◆ convQ8i()

void onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8i ( )

Definition at line 166 of file DepthwiseConvolutionLayer.cc.

{
  if (!_prepared)
  {
    prepareQ8i();
    _prepared = true;
  }
 
  int32_t output_activation_min = 0;
  int32_t output_activation_max = 0;
  CalculateActivationRangeQuantized(_activation, _output, &output_activation_min,
                                    &output_activation_max);
 
  nnfw::cker::DepthwiseConvParams op_params;
  op_params.padding_type = nnfw::cker::PaddingType::kSame;
  op_params.padding_values.width = _paddingLeft;
  op_params.padding_values.height = _paddingTop;
  op_params.depth_multiplier = _multiplier;
  op_params.stride_width = _strideWidth;
  op_params.stride_height = _strideHeight;
  op_params.dilation_width_factor = _dilationWidth;
  op_params.dilation_height_factor = _dilationHeight;
  op_params.input_offset = -_input->data_zero_point();
  op_params.weights_offset = 0;
  op_params.output_offset = _output->data_zero_point();
  op_params.quantized_activation_min = output_activation_min;
  op_params.quantized_activation_max = output_activation_max;
 
  nnfw::cker::optimized_integer_ops::DepthwiseConvPerChannel(
    op_params, _per_channel_output_multiplier.data(), _per_channel_output_shift.data(),
    getShape(_input), getBuffer<int8_t>(_input), getShape(_kernel), getBuffer<int8_t>(_kernel),
    getShape(_bias), getBuffer<int32_t>(_bias), getShape(_output), getBuffer<int8_t>(_output),
    _external_context->ruy_context());
}

Referenced by run().

◆ convQ8iHybridPerChannel()

void onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8iHybridPerChannel ( )

Definition at line 201 of file DepthwiseConvolutionLayer.cc.

{
  if (!_prepared)
  {
    prepareQ8iHybridPerChannel();
    _prepared = true;
  }
 
  float output_activation_min = 0, output_activation_max = 0;
  CalculateActivationRange(_activation, &output_activation_min, &output_activation_max);
 
  auto input_shape = getShape(_input);
  const int batch_size = input_shape.Dims(0);
  const int input_size = input_shape.FlatSize() / batch_size;
 
  auto scaling_factors_ptr = _input_scaling_factors.data();
  auto input_offsets_ptr = _input_offsets.data();
 
  for (int b = 0; b < batch_size; ++b)
  {
    const int offset = b * input_size;
    nnfw::cker::PortableAsymmetricQuantizeFloats(getBuffer<float>(_input) + offset, input_size,
                                                 _input_quantized.data() + offset,
                                                 &scaling_factors_ptr[b], &input_offsets_ptr[b]);
  }
 
  nnfw::cker::DepthwiseConvParams op_params;
  op_params.padding_values.width = _paddingLeft;
  op_params.padding_values.height = _paddingTop;
  op_params.depth_multiplier = _multiplier;
  op_params.stride_width = _strideWidth;
  op_params.stride_height = _strideHeight;
  op_params.dilation_width_factor = _dilationWidth;
  op_params.dilation_height_factor = _dilationHeight;
  op_params.float_activation_min = output_activation_min;
  op_params.float_activation_max = output_activation_max;
 
  nnfw::cker::reference_integer_ops::DepthwiseConvHybridPerChannel(
    op_params, _input_scaling_factors.data(), getShape(_input), _input_quantized.data(),
    getShape(_kernel), getBuffer<int8_t>(_kernel), getShape(_bias), getBuffer<float>(_bias),
    getShape(_output), getBuffer<float>(_output), _kernel->data_scales().data(),
    _input_offsets.data());
}

Referenced by run().

◆ convQ8uPerChannel()

void onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerChannel ( )

Definition at line 138 of file DepthwiseConvolutionLayer.cc.

{
  nnfw::cker::DepthwiseConvParams op_params;
  op_params.padding_values.width = _paddingLeft;
  op_params.padding_values.height = _paddingTop;
  op_params.stride_width = _strideWidth;
  op_params.stride_height = _strideHeight;
  op_params.dilation_width_factor = _dilationWidth;
  op_params.dilation_height_factor = _dilationHeight;
  op_params.depth_multiplier = _multiplier;
  op_params.input_offset = -_input->data_zero_point();
  op_params.output_offset = _output->data_zero_point();
  int32_t output_activation_min = 0;
  int32_t output_activation_max = 0;
  CalculateActivationRangeQuantized(_activation, _output, &output_activation_min,
                                    &output_activation_max);
  op_params.quantized_activation_min = output_activation_min;
  op_params.quantized_activation_max = output_activation_max;
  // NOTE: The following fields of ConvParams are not used:
  // padding_type, weights_offset, output_{multiplier,shift}, float_activation_{min,max}
 
  nnfw::cker::reference_integer_ops::DepthwiseConvPerChannel(
    op_params, _per_channel_output_multiplier.data(), _per_channel_output_shift.data(),
    getShape(_input), getBuffer<uint8_t>(_input), getShape(_kernel), getBuffer<uint8_t>(_kernel),
    _kernel->data_zero_points().data(), getShape(_bias), getBuffer<int32_t>(_bias),
    getShape(_output), getBuffer<uint8_t>(_output));
}

Referenced by run().

◆ convQ8uPerTensor()

void onert::backend::cpu::ops::DepthwiseConvolutionLayer::convQ8uPerTensor ( )

Definition at line 103 of file DepthwiseConvolutionLayer.cc.

{
  int32_t output_activation_min = 0;
  int32_t output_activation_max = 0;
  CalculateActivationRangeQuantized(_activation, _output, &output_activation_min,
                                    &output_activation_max);
 
  double real_multiplier = 0.0;
  int32_t output_multiplier = 0;
  int32_t output_shift = 0;
  GetQuantizedConvolutionMultiplier(_input, _kernel, _bias, _output, &real_multiplier);
  QuantizeMultiplier(real_multiplier, &output_multiplier, &output_shift);
 
  nnfw::cker::DepthwiseConvParams op_params;
  op_params.stride_width = _strideWidth;
  op_params.stride_height = _strideHeight;
  op_params.dilation_width_factor = _dilationWidth;
  op_params.dilation_height_factor = _dilationHeight;
  op_params.padding_values.width = _paddingLeft;
  op_params.padding_values.height = _paddingTop;
  op_params.depth_multiplier = _multiplier;
  op_params.input_offset = -_input->data_zero_point();
  op_params.weights_offset = -_kernel->data_zero_point();
  op_params.output_offset = _output->data_zero_point();
  op_params.output_multiplier = output_multiplier;
  op_params.output_shift = output_shift;
  op_params.quantized_activation_min = output_activation_min;
  op_params.quantized_activation_max = output_activation_max;
 
  nnfw::cker::DepthwiseConv<uint8_t, int32_t>(
    op_params, getShape(_input), getBuffer<uint8_t>(_input), getShape(_kernel),
    getBuffer<uint8_t>(_kernel), getShape(_bias), getBuffer<int32_t>(_bias), getShape(_output),
    getBuffer<uint8_t>(_output), _external_context->ruy_context());
}

Referenced by run().

◆ run()

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

overridevirtual

Implements onert::exec::IFunction.

Definition at line 342 of file DepthwiseConvolutionLayer.cc.

{
  if (_is_hybrid)
  {
    convQ8iHybridPerChannel();
  }
  else if (_input->data_type() == OperandType::FLOAT32)
  {
    convFloat32();
  }
  else if (_input->data_type() == OperandType::QUANT_UINT8_ASYMM)
  {
    const bool per_channel_quantized = _kernel->data_scales().size() > 1;
    if (per_channel_quantized)
      convQ8uPerChannel();
    else
      convQ8uPerTensor();
  }
  else if (_input->data_type() == OperandType::QUANT_INT8_ASYMM)
  {
    convQ8i();
  }
  else
  {
    throw std::runtime_error{"DepthwiseConv: unsupported data type"};
  }
}