#include <DepthwiseConvolutionLayer.h>

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

[legend]

Public Member Functions
	DepthwiseConvolutionLayer ()

void	configureBackward (IPortableTensor back_prop_input, IPortableTensor grad_weights, IPortableTensor grad_bias, const IPortableTensor back_prop_output, const ir::Activation activation)

void	forward (bool training) override

void	backward () override

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

virtual std::optional< backend::train::LayerScopeTensors >	registerLayerScopeTensors ()

Public Member Functions inherited from onert::backend::cpu::ops::DepthwiseConvolutionLayer
	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 ()

Additional Inherited Members
Protected Attributes inherited from onert::backend::cpu::ops::DepthwiseConvolutionLayer
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}

Detailed Description

Definition at line 30 of file DepthwiseConvolutionLayer.h.

Constructor & Destructor Documentation

◆ DepthwiseConvolutionLayer()

onert::backend::train::ops::DepthwiseConvolutionLayer::DepthwiseConvolutionLayer ( )

Definition at line 28 of file DepthwiseConvolutionLayer.cc.

  : cpu::ops::DepthwiseConvolutionLayer(), _grad_weights{nullptr}, _grad_bias{nullptr},
    _back_prop_input{nullptr}, _back_prop_output{nullptr}, _act_back_prop_output{nullptr},
    _use_padded_filter{false}, _padded_filter{nullptr}, _filter_buffers{nullptr},
    _filter_dim_buffers{nullptr}
{
  // DO NOTHING
}

Member Function Documentation

◆ backward()

void onert::backend::train::ops::DepthwiseConvolutionLayer::backward ( )

overridevirtual

Implements onert::exec::train::ITrainableFunction.

Definition at line 111 of file DepthwiseConvolutionLayer.cc.

{
  const auto data_type = _back_prop_output->data_type();
  assert(data_type == _input->data_type());
  switch (data_type)
  {
    case OperandType::FLOAT32:
    {
      assert(data_type == _grad_bias->data_type());
      backwardFloat32();
      break;
    }
    default:
      throw std::runtime_error{"train DepthwiseConvolutionLayer: unsupported data type"};
  }
}

References onert::backend::cpu::ops::DepthwiseConvolutionLayer::_input, and onert::backend::IPortableTensor::data_type().

◆ configureBackward()

void onert::backend::train::ops::DepthwiseConvolutionLayer::configureBackward	(	IPortableTensor *	back_prop_input,
		IPortableTensor *	grad_weights,
		IPortableTensor *	grad_bias,
		const IPortableTensor *	back_prop_output,
		const ir::Activation	activation
	)

Definition at line 37 of file DepthwiseConvolutionLayer.cc.

{
  _back_prop_input = back_prop_input;
  _back_prop_output = back_prop_output;
  _grad_weights = grad_weights;
  _grad_bias = grad_bias;
 
  if (_dilationWidth != 1 || _dilationHeight != 1)
    throw std::runtime_error("train DepthwiseConvolutionLayer: Unsupported dilation yet");
 
  if (activation != ir::Activation::NONE)
  {
    _act_back_prop_output = std::make_unique<BackPropTensor>(_back_prop_output->get_info());
    _act_back_prop_output->setBuffer(
      std::make_shared<basic::Allocator>(_act_back_prop_output->total_size()));
  }
 
  const int64_t k_packet_size = [&]() {
    const auto data_type = _back_prop_output->data_type();
    switch (data_type)
    {
      case OperandType::FLOAT32:
      {
        return nnfw::cker::eigen_support::kPacketSize<float>();
      }
      default:
        throw std::runtime_error("train DepthwiseConvolutionLayer: unsupported data type");
    }
  }();
 
  const auto incoming_shape = getShape(_back_prop_output);
  const int out_depth = incoming_shape.Dims(3);
 
  const int padded_filter_inner_dim_size =
    ((out_depth + k_packet_size - 1) / k_packet_size) * k_packet_size;
 
  // prepare out_bprop and in_bprop buffer for cker
  // NOTE The Eigen library uses both main thread as well as a thread pool.
  // Therefore, it needs to add an additional memory buffer for main thread.
  const int thread_count = nnfw::cker::eigen_support::getThreadCount() + 1;
 
  auto filter_dim_buffers_info = ir::OperandInfo(_back_prop_input->get_info());
  filter_dim_buffers_info.shape({thread_count, padded_filter_inner_dim_size});
  _filter_dim_buffers = std::make_unique<Tensor>(filter_dim_buffers_info);
  _filter_dim_buffers->setBuffer(
    std::make_shared<basic::Allocator>(_filter_dim_buffers->total_size()));
 
  _use_padded_filter = (out_depth % k_packet_size) == 0 ? false : true;
 
  const auto filter_shape = getShape(_kernel);
  const int batch = incoming_shape.Dims(0);
 
  const int filter_rows = filter_shape.Dims(1);
  const int filter_cols = filter_shape.Dims(2);
  const int filter_spatial_size = filter_rows * filter_cols;
 
  // prepare padded_filter buffer for cker
  auto padded_filter_info = ir::OperandInfo(_kernel->get_info());
  padded_filter_info.shape({batch, filter_spatial_size, padded_filter_inner_dim_size});
  _padded_filter = std::make_unique<Tensor>(padded_filter_info);
  _padded_filter->setBuffer(std::make_shared<basic::Allocator>(_padded_filter->total_size()));
 
  auto filter_buffers_info = ir::OperandInfo(_kernel->get_info());
  filter_buffers_info.shape({thread_count, filter_spatial_size, padded_filter_inner_dim_size});
  _filter_buffers = std::make_unique<Tensor>(filter_buffers_info);
  _filter_buffers->setBuffer(std::make_shared<basic::Allocator>(_filter_buffers->total_size()));
}