onert::backend::train::KernelGenerator Class Reference

#include <KernelGenerator.h>

Collaboration diagram for onert::backend::train::KernelGenerator:

Public Member Functions
	KernelGenerator (const ir::train::TrainableGraph &tgraph, const std::shared_ptr< TensorRegistry > &tensor_reg, const std::shared_ptr< ExternalContext > &external_context, const exec::train::optimizer::Optimizer *optimizer)
std::unique_ptr< exec::train::TrainableFnSequence >	generate (ir::OperationIndex op_ind) override
void	visit (const ir::train::operation::BinaryArithmetic &) override
void	visit (const ir::train::operation::Conv2D &) override
void	visit (const ir::train::operation::DepthwiseConv2D &) override
void	visit (const ir::train::operation::ElementwiseActivation &) override
void	visit (const ir::train::operation::FullyConnected &) override
void	visit (const ir::train::operation::Loss &) override
void	visit (const ir::train::operation::Pad &) override
void	visit (const ir::train::operation::Pool2D &) override
void	visit (const ir::train::operation::Reduce &node) override
void	visit (const ir::train::operation::Reshape &node) override
void	visit (const ir::train::operation::Softmax &node) override
Public Member Functions inherited from onert::backend::train::KernelGeneratorBase
virtual	~KernelGeneratorBase ()=default
	KernelGeneratorBase (const ir::train::TrainableGraph &tgraph)
Public Member Functions inherited from onert::ir::train::TrainableOperationVisitor
virtual	~TrainableOperationVisitor ()=default

Additional Inherited Members
Protected Attributes inherited from onert::backend::train::KernelGeneratorBase
const ir::train::TrainableGraph &	_tgraph
std::unique_ptr< exec::train::ITrainableFunction >	_return_fn

Detailed Description

Definition at line 35 of file KernelGenerator.h.

Constructor & Destructor Documentation

KernelGenerator()

onert::backend::train::KernelGenerator::KernelGenerator	(	const ir::train::TrainableGraph &	tgraph,
		const std::shared_ptr< TensorRegistry > &	tensor_reg,
		const std::shared_ptr< ExternalContext > &	external_context,
		const exec::train::optimizer::Optimizer *	optimizer
	)

Definition at line 142 of file KernelGenerator.cc.

  : backend::train::KernelGeneratorBase{tgraph}, _tensor_reg{tensor_reg},
    _external_context(external_context), _optimizer{optimizer}, _update_funcs{}, _node_to_idx{}
{
  tgraph.operations().iterate(
    [&](const onert::ir::OperationIndex &idx, const onert::ir::IOperation &op) {
      assert(_node_to_idx.find(&op) == _node_to_idx.end());
      _node_to_idx[&op] = idx;
    });
}

References onert::util::ObjectManager< Index, Object >::iterate(), and onert::ir::train::TrainableGraph::operations().

Member Function Documentation

generate()

std::unique_ptr< exec::train::TrainableFnSequence > onert::backend::train::KernelGenerator::generate ( ir::OperationIndex  op_ind )

overridevirtual

Implements onert::backend::train::KernelGeneratorBase.

Definition at line 110 of file KernelGenerator.cc.

{
  // NOTE This function is related to planning tensors. If you change this function, you should
  //      also consider to change planning tensors.
 
  auto ret = std::make_unique<exec::train::TrainableFnSequence>();
 
  const auto &op = _tgraph.operation(idx);
 
  // NOTE appendBackPropAccumulators() must be called before appending _return_fn to
  //      TrainableFnSequence as long as both are appended to the same TrainableFnSequence.
  appendBackPropAccumulators(op, idx, _tensor_reg.get(), ret.get());
 
  op.accept(*this);
  assert(_return_fn);
  ret->append(std::move(_return_fn));
 
  for (auto &&update_fn : _update_funcs)
    ret->append(std::move(update_fn));
  _update_funcs.clear();
 
  for (auto &&ind : (op.getInputs() | ir::Remove::UNDEFINED) + op.getOutputs())
  {
    auto tensor = _tensor_reg->getNonConstTensor(ind);
    if (tensor)
    {
      tensor->increase_ref();
    }
  }
  return ret;
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::backend::train::KernelGeneratorBase::_tgraph, onert::ir::train::TrainableGraph::operation(), and onert::ir::UNDEFINED.

visit() [1/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::BinaryArithmetic &  node )

override

Definition at line 156 of file KernelGenerator.cc.

{
  using ir::train::operation::BinaryArithmetic;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto lhs_index{node.getInputs().at(BinaryArithmetic::Input::LHS)};
  const auto rhs_index{node.getInputs().at(BinaryArithmetic::Input::RHS)};
 
  const auto arithmetic_type = node.param().arithmetic_type;
  const auto activation = node.param().activation;
 
  auto output_tensor = _tensor_reg->getPortableTensor(output_index);
  auto lhs_tensor = _tensor_reg->getPortableTensor(lhs_index);
  auto rhs_tensor = _tensor_reg->getPortableTensor(rhs_index);
 
  auto fn = std::make_unique<ops::BinaryArithmeticLayer>();
  fn->configure(lhs_tensor, rhs_tensor, output_tensor, activation,
                static_cast<cpu::ops::ArithmeticType>(arithmetic_type));
 
  if (node.isRequiredForBackward())
  {
    auto back_prop_output_tensor = getBackPropOut(output_index);
    auto back_prop_lhs_tensor = getBackPropIn(node, lhs_index);
    auto back_prop_rhs_tensor = getBackPropIn(node, rhs_index);
 
    fn->configureBackward(back_prop_lhs_tensor, back_prop_rhs_tensor, back_prop_output_tensor,
                          activation, static_cast<train::ops::ArithmeticType>(arithmetic_type));
  }
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::operation::BinaryArithmetic::Param::activation, onert::ir::operation::BinaryArithmetic::Param::arithmetic_type, onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableOperation::isRequiredForBackward(), and onert::ir::operation::BinaryArithmetic::param().

visit() [2/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Conv2D &  node )

override

Definition at line 187 of file KernelGenerator.cc.

{
  using ir::train::operation::Conv2D;
 
  const auto out_index{node.getOutputs().at(0)};
  const auto in_index{node.getInputs().at(Conv2D::Input::INPUT)};
  const auto ker_index{node.getInputs().at(Conv2D::Input::KERNEL)};
  const auto bias_index{node.getInputs().at(Conv2D::Input::BIAS)};
 
  auto out_tensor = _tensor_reg->getPortableTensor(out_index);
  auto in_tensor = _tensor_reg->getPortableTensor(in_index);
  auto ker_tensor = _tensor_reg->getTrainableTensor(ker_index);
  auto bias_tensor = _tensor_reg->getTrainableTensor(bias_index);
 
  // Generate kernel
  const auto stride = node.param().stride;
  const auto activation = node.param().activation;
  const auto &param_padding = node.param().padding;
  const auto dilation = node.param().dilation;
  auto fn = std::make_unique<ops::ConvolutionLayer>();
 
  auto &operands = _tgraph.operands();
  const auto ifm_shape = operands.at(in_index).shape().asFeature();
  const auto ofm_shape = operands.at(out_index).shape().asFeature();
  // Kernel format is [depth_out, kernel_height, kernel_width, depth_in].
  const auto &ker_shape = operands.at(ker_index).shape();
  const auto ker_height = ker_shape.dim(1);
  const auto ker_width = ker_shape.dim(2);
 
  const auto padding =
    ir::calculatePadding(param_padding, ifm_shape, ofm_shape, stride, ker_width, ker_height,
                         dilation.width_factor, dilation.height_factor);
 
  const bool is_cacheable_weights = false;
  fn->configure(in_tensor, ker_tensor, bias_tensor, param_padding.type, padding.left, padding.right,
                padding.top, padding.bottom, stride.horizontal, stride.vertical,
                dilation.width_factor, dilation.height_factor, activation, out_tensor,
                is_cacheable_weights);
 
  auto ker_grad_tensor = _tensor_reg->getGradientTensor(ker_index);
  auto bias_grad_tensor = _tensor_reg->getGradientTensor(bias_index);
 
  if (node.isRequiredForBackward())
  {
 
    auto out_back_prop_tensor = getBackPropOut(out_index);
    auto in_back_prop_tensor = getBackPropIn(node, in_index);
 
    fn->configureBackward(ker_tensor, in_back_prop_tensor, ker_grad_tensor, bias_grad_tensor,
                          out_back_prop_tensor, activation);
 
    // Generate GradientApplier
    if (bias_tensor)
      _update_funcs.emplace_back(
        generateGradientApplier(_optimizer, bias_grad_tensor, bias_tensor));
    _update_funcs.emplace_back(generateGradientApplier(_optimizer, ker_grad_tensor, ker_tensor));
  }
 
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::backend::train::KernelGeneratorBase::_tgraph, onert::ir::operation::Conv2D::Param::activation, onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), bias_tensor, onert::ir::calculatePadding(), onert::ir::operation::Conv2D::Param::dilation, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableOperation::isRequiredForBackward(), ker_tensor, onert::ir::train::TrainableGraph::operands(), onert::ir::operation::Conv2D::Param::padding, onert::ir::operation::Conv2D::param(), and onert::ir::operation::Conv2D::Param::stride.

visit() [3/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::DepthwiseConv2D &  node )

override

Definition at line 248 of file KernelGenerator.cc.

{
  using ir::train::operation::DepthwiseConv2D;
 
  const auto ofm_index{node.getOutputs().at(0)};
  const auto ifm_index{node.getInputs().at(DepthwiseConv2D::Input::INPUT)};
  const auto ker_index{node.getInputs().at(DepthwiseConv2D::Input::KERNEL)};
  const auto bias_index{node.getInputs().at(DepthwiseConv2D::Input::BIAS)};
 
  auto ofm_tensor = _tensor_reg->getPortableTensor(ofm_index);
  auto ifm_tensor = _tensor_reg->getPortableTensor(ifm_index);
  auto ker_tensor = _tensor_reg->getTrainableTensor(ker_index);
  auto bias_tensor = _tensor_reg->getTrainableTensor(bias_index);
 
  const auto stride = node.param().stride;
  const auto &operands = _tgraph.operands();
  const auto ofm_shape = operands.at(ofm_index).shape().asFeature();
  const auto ifm_shape = operands.at(ifm_index).shape().asFeature();
  // Kernel format is [1, kernel_height, kernel_width, depth_out].
  const auto &ker_shape = operands.at(ker_index).shape();
  const auto ker_height = ker_shape.dim(1);
  const auto ker_width = ker_shape.dim(2);
  const auto dilation_width = node.param().dilation.width_factor;
  const auto dilation_height = node.param().dilation.height_factor;
  const auto padding = ir::calculatePadding(node.param().padding, ifm_shape, ofm_shape, stride,
                                            ker_width, ker_height, dilation_width, dilation_height);
  const auto multiplier = node.param().multiplier;
  const auto activation = node.param().activation;
 
  auto fn = std::make_unique<ops::DepthwiseConvolutionLayer>();
 
  fn->configure(ifm_tensor, ker_tensor, bias_tensor, padding.left, padding.right, padding.top,
                padding.bottom, stride.horizontal, stride.vertical, multiplier, dilation_width,
                dilation_height, activation, ofm_tensor, _external_context);
 
  if (node.isRequiredForBackward())
  {
    auto ker_grad_tensor = _tensor_reg->getGradientTensor(ker_index);
    auto bias_grad_tensor = _tensor_reg->getGradientTensor(bias_index);
 
    auto ofm_back_prop_tensor = getBackPropOut(ofm_index);
    auto ifm_back_prop_tensor = getBackPropIn(node, ifm_index);
 
    fn->configureBackward(ifm_back_prop_tensor, ker_grad_tensor, bias_grad_tensor,
                          ofm_back_prop_tensor, activation);
 
    // Generate GradientApplier
    if (bias_tensor)
      _update_funcs.emplace_back(
        generateGradientApplier(_optimizer, bias_grad_tensor, bias_tensor));
    _update_funcs.emplace_back(generateGradientApplier(_optimizer, ker_grad_tensor, ker_tensor));
  }
 
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::backend::train::KernelGeneratorBase::_tgraph, onert::ir::operation::DepthwiseConv2D::Param::activation, onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), bias_tensor, onert::ir::calculatePadding(), onert::ir::operation::DepthwiseConv2D::Param::dilation, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::Dilation::height_factor, onert::ir::train::TrainableOperation::isRequiredForBackward(), ker_tensor, onert::ir::operation::DepthwiseConv2D::Param::multiplier, onert::ir::train::TrainableGraph::operands(), onert::ir::operation::DepthwiseConv2D::Param::padding, onert::ir::operation::DepthwiseConv2D::param(), onert::ir::operation::DepthwiseConv2D::Param::stride, and onert::ir::Dilation::width_factor.

visit() [4/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::ElementwiseActivation &  node )

override

Definition at line 304 of file KernelGenerator.cc.

{
  using ir::train::operation::ElementwiseActivation;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ElementwiseActivation::Input::INPUT)};
 
  auto output_tensor = _tensor_reg->getPortableTensor(output_index);
  auto input_tensor = _tensor_reg->getPortableTensor(input_index);
 
  auto fn = std::make_unique<ops::ElementwiseActivationLayer>();
 
  auto convertToInferActivationType = [](const ir::operation::ElementwiseActivation::Type &type) {
    switch (type)
    {
      case ir::operation::ElementwiseActivation::Type::RELU:
        return cpu::ops::ElementwiseActivationType::kReLU;
      default:
        throw std::invalid_argument("Unsupported ElementwiseActivation::Type");
    }
  };
 
  fn->configure(input_tensor, output_tensor, node.param().alpha, node.param().beta,
                node.param().approximate, convertToInferActivationType(node.param().op_type));
 
  if (node.isRequiredForBackward())
  {
    auto back_prop_input_tensor = getBackPropIn(node, input_index);
    auto back_prop_output_tensor = getBackPropOut(output_index);
 
    fn->configureBackward(input_tensor, back_prop_input_tensor, back_prop_output_tensor,
                          node.param().alpha, node.param().beta,
                          convertElementwiseActivationType(node.param().op_type));
  }
 
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::operation::ElementwiseActivation::Param::alpha, onert::ir::operation::ElementwiseActivation::Param::approximate, onert::ir::OperandIndexSequence::at(), onert::ir::operation::ElementwiseActivation::Param::beta, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableOperation::isRequiredForBackward(), onert::backend::cpu::ops::kReLU, onert::ir::operation::ElementwiseActivation::Param::op_type, onert::ir::operation::ElementwiseActivation::param(), and onert::ir::operation::ElementwiseActivation::RELU.

visit() [5/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::FullyConnected &  node )

override

Definition at line 342 of file KernelGenerator.cc.

{
  using ir::train::operation::FullyConnected;
 
  const auto out_index{node.getOutputs().at(0)};
  const auto in_index{node.getInputs().at(FullyConnected::Input::INPUT)};
  const auto weights_index{node.getInputs().at(FullyConnected::Input::WEIGHT)};
  const auto bias_index{node.getInputs().at(FullyConnected::Input::BIAS)};
 
  auto out_tensor = _tensor_reg->getPortableTensor(out_index);
  auto in_tensor = _tensor_reg->getPortableTensor(in_index);
  auto weights_tensor = _tensor_reg->getTrainableTensor(weights_index);
  auto bias_tensor = _tensor_reg->getTrainableTensor(bias_index);
 
  // Generate kernel
  const auto activation = node.param().activation;
  const auto weights_format = node.param().weights_format;
 
  auto fn = std::make_unique<ops::FullyConnectedLayer>();
 
  fn->configure(in_tensor, weights_tensor, bias_tensor, activation, weights_format, out_tensor,
                _external_context);
 
  if (node.isRequiredForBackward())
  {
    auto out_back_prop_tensor = getBackPropOut(out_index);
    auto in_back_prop_tensor = getBackPropIn(node, in_index);
    auto weights_grad_tensor = _tensor_reg->getGradientTensor(weights_index);
    auto bias_grad_tensor = _tensor_reg->getGradientTensor(bias_index);
 
    fn->configureBackward(in_tensor, weights_tensor, out_tensor, in_back_prop_tensor,
                          weights_grad_tensor, bias_grad_tensor, out_back_prop_tensor, activation,
                          weights_format);
 
    // Generate GradientAppliers
    if (bias_tensor)
      _update_funcs.emplace_back(
        generateGradientApplier(_optimizer, bias_grad_tensor, bias_tensor));
    _update_funcs.emplace_back(
      generateGradientApplier(_optimizer, weights_grad_tensor, weights_tensor));
  }
 
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::operation::FullyConnected::Param::activation, onert::ir::OperandIndexSequence::at(), bias_tensor, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableOperation::isRequiredForBackward(), onert::ir::operation::FullyConnected::param(), and onert::ir::operation::FullyConnected::Param::weights_format.

visit() [6/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Loss &  node )

override

Definition at line 387 of file KernelGenerator.cc.

{
  using ir::train::operation::Loss;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto y_pred_index{node.getInputs().at(Loss::Y_PRED)};
  const auto y_true_index{node.getInputs().at(Loss::Y_TRUE)};
 
  auto output_tensor = _tensor_reg->getPortableTensor(output_index);
  auto y_pred_tensor = _tensor_reg->getPortableTensor(y_pred_index);
  auto y_true_tensor = _tensor_reg->getPortableTensor(y_true_index);
 
  // TODO Use BackPropTensor directly instead of DisposableTensor if y_pred is always used by only
  //      loss
  auto back_prop_y_pred_tensor = getBackPropIn(node, y_pred_index);
 
  const auto loss_code = node.param().loss_code;
  const auto &loss_param = node.param().loss_param;
  const auto reduction_type = node.param().reduction_type;
 
  switch (loss_code)
  {
    case ir::train::LossCode::MeanSquaredError:
    {
      auto fn = std::make_unique<ops::LossMeanSquaredErrorLayer>();
      fn->configure(y_pred_tensor, y_true_tensor, output_tensor, back_prop_y_pred_tensor,
                    reduction_type);
      _return_fn = std::move(fn);
      break;
    }
    case ir::train::LossCode::CategoricalCrossentropy:
    {
      const auto y_pred_op_code = node.y_pred_op_code();
      bool is_normalization_required = (y_pred_op_code != ir::OpCode::Softmax);
      const auto cce_params = std::get_if<ir::train::CategoricalCrossentropyParam>(&loss_param);
      if (!cce_params)
      {
        throw std::runtime_error("LossLayer: Expected loss_param to be "
                                 "CategoricalCrossentropyParam but found a different type.");
      }
      auto fn = std::make_unique<ops::LossCategoricalCrossentropyLayer>();
      fn->configure(y_pred_tensor, y_true_tensor, output_tensor, back_prop_y_pred_tensor,
                    reduction_type, cce_params->axis, cce_params->label_smoothing,
                    is_normalization_required);
      _return_fn = std::move(fn);
      break;
    }
    default:
      throw std::runtime_error("LossLayer: unsupported loss type");
  }
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::OperandIndexSequence::at(), onert::ir::train::CategoricalCrossentropy, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::LossInfo::loss_code, onert::ir::train::LossInfo::loss_param, onert::ir::train::MeanSquaredError, onert::ir::train::operation::Loss::param(), onert::ir::train::LossInfo::reduction_type, and onert::ir::train::operation::Loss::y_pred_op_code().

visit() [7/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Pad &  node )

override

Definition at line 439 of file KernelGenerator.cc.

{
  const auto input_index{node.getInputs().at(ir::operation::Pad::Input::INPUT)};
  const auto pad_index{node.getInputs().at(ir::operation::Pad::Input::PAD)};
  const auto output_index{node.getOutputs().at(0)};
 
  auto input = _tensor_reg->getPortableTensor(input_index);
  auto pad = _tensor_reg->getPortableTensor(pad_index);
  auto output = _tensor_reg->getPortableTensor(output_index);
 
  auto fn = std::make_unique<ops::PadLayer>();
 
  IPortableTensor *value = nullptr;
  if (node.getInputs().size() == 3) // isPadV2
  {
    const auto value_index{node.getInputs().at(ir::operation::Pad::Input::VALUE)};
    value = _tensor_reg->getPortableTensor(value_index);
  }
 
  fn->configure(input, pad, value, output);
  if (node.isRequiredForBackward())
  {
    auto out_back_prop_tensor = getBackPropOut(output_index);
    auto in_back_prop_tensor = getBackPropIn(node, input_index);
    fn->configureBackward(in_back_prop_tensor, out_back_prop_tensor);
  }
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Pad::INPUT, onert::ir::train::TrainableOperation::isRequiredForBackward(), onert::ir::operation::Pad::PAD, onert::ir::OperandIndexSequence::size(), and onert::ir::operation::Pad::VALUE.

visit() [8/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Pool2D &  node )

override

Definition at line 468 of file KernelGenerator.cc.

{
  using ir::train::operation::Pool2D;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(0)};
 
  const auto &operands = _tgraph.operands();
  const auto &ofm_shape = operands.at(output_index).shape();
  const auto &ifm_shape = operands.at(input_index).shape();
 
  if (ifm_shape.rank() != 4)
  {
    throw std::runtime_error(node.name() + " only supports 4D tensor as input");
  }
 
  // calculate padding
  const auto stride = node.param().stride;
  const auto kh = node.param().kh;
  const auto kw = node.param().kw;
  const auto padding = ir::calculatePadding(node.param().padding, ifm_shape.asFeature(),
                                            ofm_shape.asFeature(), stride, kw, kh);
 
  auto out_tensor = _tensor_reg->getPortableTensor(output_index);
  auto in_tensor = _tensor_reg->getPortableTensor(input_index);
 
  const auto activation = node.param().activation;
  const auto pool_type = convertPoolType(node.param().op_type);
 
  auto fn = std::make_unique<ops::PoolLayer>();
 
  auto convertToInferPoolType = [](const train::ops::PoolType &pool_type) {
    switch (pool_type)
    {
      case train::ops::PoolType::kMax:
        return cpu::ops::PoolType::kMax;
      case train::ops::PoolType::kAvg:
        return cpu::ops::PoolType::kAvg;
      default:
        throw std::runtime_error("PoolLayer: Unsupported pool type yet");
    }
  };
 
  fn->configure(in_tensor, padding.left, padding.right, padding.top, padding.bottom,
                stride.horizontal, stride.vertical, kw, kh, activation, out_tensor,
                convertToInferPoolType(pool_type));
 
  if (node.isRequiredForBackward())
  {
    auto out_back_prop_tensor = getBackPropOut(output_index);
    auto in_back_prop_tensor = getBackPropIn(node, input_index);
    fn->configureBackward(padding.left, padding.right, padding.top, padding.bottom,
                          stride.horizontal, stride.vertical, kw, kh, activation, pool_type,
                          out_tensor, in_back_prop_tensor, out_back_prop_tensor);
  }
 
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::backend::train::KernelGeneratorBase::_tgraph, onert::ir::operation::Pool2D::Param::activation, onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), onert::ir::calculatePadding(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableOperation::isRequiredForBackward(), onert::backend::cpu::ops::kAvg, onert::backend::train::ops::kAvg, onert::ir::operation::Pool2D::Param::kh, onert::backend::cpu::ops::kMax, onert::backend::train::ops::kMax, onert::ir::operation::Pool2D::Param::kw, onert::ir::operation::Pool2D::name(), onert::ir::operation::Pool2D::Param::op_type, onert::ir::train::TrainableGraph::operands(), onert::ir::operation::Pool2D::Param::padding, onert::ir::operation::Pool2D::param(), and onert::ir::operation::Pool2D::Param::stride.

visit() [9/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Reduce &  node )

override

Definition at line 527 of file KernelGenerator.cc.

{
  using ir::train::operation::Reduce;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(Reduce::Input::INPUT)};
  const auto axes_index{node.getInputs().at(Reduce::Input::AXES)};
 
  const auto keep_dims = node.param().keep_dims;
 
  auto output_tensor = _tensor_reg->getPortableTensor(output_index);
  auto input_tensor = _tensor_reg->getPortableTensor(input_index);
  auto axes_tensor = _tensor_reg->getPortableTensor(axes_index);
 
  if (node.param().reduce_type == ir::operation::Reduce::ReduceType::MEAN)
  {
    auto fn = std::make_unique<ops::MeanLayer>();
    fn->configure(input_tensor, axes_tensor, output_tensor, keep_dims);
    if (node.isRequiredForBackward())
    {
      auto back_prop_output_tensor = getBackPropOut(output_index);
      auto back_prop_input_tensor = getBackPropIn(node, input_index);
      fn->configureBackward(back_prop_input_tensor, back_prop_output_tensor);
    }
    _return_fn = std::move(fn);
  }
  else
  {
    throw std::runtime_error("ReduceLayer: unsupported reduce type");
  }
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableOperation::isRequiredForBackward(), onert::ir::operation::Reduce::Param::keep_dims, onert::ir::operation::Reduce::MEAN, onert::ir::operation::Reduce::param(), and onert::ir::operation::Reduce::Param::reduce_type.

visit() [10/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Reshape &  node )

override

Definition at line 559 of file KernelGenerator.cc.

{
  using ir::train::operation::Reshape;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::Reshape::Input::INPUT)};
 
  auto output_tensor = _tensor_reg->getPortableTensor(output_index);
  auto input_tensor = _tensor_reg->getPortableTensor(input_index);
 
  // optional 2nd input
  IPortableTensor *shape_tensor = nullptr;
 
  if (node.getInputs().size() == 2)
  {
    const auto shape_index{node.getInputs().at(ir::operation::Reshape::Input::SHAPE)};
    shape_tensor = _tensor_reg->getPortableTensor(shape_index);
  }
 
  auto fn = std::make_unique<ops::ReshapeLayer>();
 
  fn->configure(input_tensor, shape_tensor, output_tensor);
  if (node.isRequiredForBackward())
  {
    auto output_back_prop_tensor = getBackPropOut(output_index);
    auto input_back_prop_tensor = getBackPropIn(node, input_index);
    fn->configureBackward(input_back_prop_tensor, output_back_prop_tensor);
  }
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Reshape::INPUT, onert::ir::train::TrainableOperation::isRequiredForBackward(), onert::ir::operation::Reshape::SHAPE, and onert::ir::OperandIndexSequence::size().

visit() [11/11]

void onert::backend::train::KernelGenerator::visit ( const ir::train::operation::Softmax &  node )

override

Definition at line 590 of file KernelGenerator.cc.

{
  using ir::train::operation::Softmax;
 
  const auto output_index{node.getOutputs().at(0)};
  const auto input_index{node.getInputs().at(ir::operation::Softmax::Input::INPUT)};
 
  const auto beta = node.param().beta;
 
  auto output_tensor = _tensor_reg->getPortableTensor(output_index);
  auto input_tensor = _tensor_reg->getPortableTensor(input_index);
 
  auto fn = std::make_unique<ops::SoftMaxLayer>();
 
  fn->configure(input_tensor, beta, output_tensor);
 
  if (node.isRequiredForBackward())
  {
    auto output_back_prop_tensor = getBackPropOut(output_index);
    auto input_back_prop_tensor = getBackPropIn(node, input_index);
    fn->configureBackward(input_back_prop_tensor, output_back_prop_tensor);
  }
  _return_fn = std::move(fn);
}

References onert::backend::train::KernelGeneratorBase::_return_fn, onert::ir::OperandIndexSequence::at(), onert::ir::operation::Softmax::Param::beta, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Softmax::INPUT, onert::ir::train::TrainableOperation::isRequiredForBackward(), and onert::ir::operation::Softmax::param().

---

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

• runtime/onert/backend/train/KernelGenerator.h
• runtime/onert/backend/train/KernelGenerator.cc