onert::ir::train::UseDefGenerator Class Reference

#include <UseDefGenerator.h>

Collaboration diagram for onert::ir::train::UseDefGenerator:

Public Member Functions
	UseDefGenerator (void)=delete
	UseDefGenerator (const TrainableGraph &tgraph)
UseDefChains	operator() ()
void	visit (const train::operation::BinaryArithmetic &node) override
void	visit (const train::operation::Conv2D &node) override
void	visit (const train::operation::DepthwiseConv2D &node) override
void	visit (const train::operation::ElementwiseActivation &node) override
void	visit (const train::operation::FullyConnected &node) override
void	visit (const train::operation::Loss &node) override
void	visit (const train::operation::Pad &node) override
void	visit (const train::operation::Pool2D &node) override
void	visit (const train::operation::Reduce &node) override
void	visit (const train::operation::Reshape &node) override
void	visit (const train::operation::Softmax &node) override
Public Member Functions inherited from onert::ir::train::UseDefGeneratorBase
virtual	~UseDefGeneratorBase ()=default
Public Member Functions inherited from onert::ir::train::TrainableOperationVisitor
virtual	~TrainableOperationVisitor ()=default

Detailed Description

Definition at line 57 of file UseDefGenerator.h.

Constructor & Destructor Documentation

UseDefGenerator() [1/2]

onert::ir::train::UseDefGenerator::UseDefGenerator ( void  )

delete

UseDefGenerator() [2/2]

onert::ir::train::UseDefGenerator::UseDefGenerator

(

const TrainableGraph &

tgraph

)

Definition at line 35 of file UseDefGenerator.cc.

  : _tgraph{tgraph}, _node_to_idx{}, _training_usedefs{}
{
  const auto order = _tgraph.topolSortOperations();
  for (const auto &index : order)
  {
    const auto &node = _tgraph.operation(index);
    assert(_node_to_idx.find(&node) == _node_to_idx.end());
    _node_to_idx[&node] = index;
  }
 
  // Check whether loss exists
  assert(std::any_of(order.begin(), order.end(),
                     [&](const auto &index) {
                       return _tgraph.operation(index).opcode() == ir::OpCode::Loss;
                     }) &&
         "Loss does not exist");
}

References onert::ir::train::TrainableGraph::operation(), and onert::ir::train::TrainableGraph::topolSortOperations().

Member Function Documentation

operator()()

UseDefChains onert::ir::train::UseDefGenerator::operator()

(

)

Definition at line 54 of file UseDefGenerator.cc.

{
  const auto &graph = _tgraph.graph();
  assert(ir::verifier::EdgeChecker().verify(graph));
 
  _training_usedefs.clear();
  graph.operands().iterate([&](const ir::OperandIndex &idx, const ir::Operand &operand) {
    // Initialize as emtpy UseDefChain
    const auto empty_usedef_chain = UseDefChain{operand};
    _training_usedefs.emplace(TrainingOperandIndex{idx, true}, empty_usedef_chain);
    _training_usedefs.emplace(TrainingOperandIndex{idx, false}, empty_usedef_chain);
  });
 
  initForForwardingNodes();
 
  initForBackwardingNodes();
 
  return _training_usedefs;
}

References onert::ir::train::TrainableGraph::graph().

visit() [1/11]

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

override

Definition at line 74 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert uses of forwarding output
  if (node.param().activation != ir::Activation::NONE)
  {
    const auto &out_index = node.getOutputs().at(0);
    const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
    insertUse(out_forwarding_index, backwarding_op_index);
  }
 
  for (const auto &in_index : node.getInputs() | ir::Remove::UNDEFINED | ir::Remove::DUPLICATED)
  {
    // Insert use of forwarding inputs
    const auto in_forwarding_index = TrainingOperandIndex{in_index, true};
    insertUse(in_forwarding_index, backwarding_op_index);
 
    // Set def of backwarding(backprop) inputs
    const auto outgoing_index = TrainingOperandIndex{in_index, false};
    insertBackPropDef(outgoing_index, backwarding_op_index);
  }
}

References onert::ir::operation::BinaryArithmetic::Param::activation, onert::ir::OperandIndexSequence::at(), onert::ir::DUPLICATED, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::NONE, onert::ir::operation::BinaryArithmetic::param(), and onert::ir::UNDEFINED.

visit() [2/11]

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

override

Definition at line 100 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of forwarding inputs
  const auto &in_index = node.getInputs().at(train::operation::Conv2D::Input::INPUT);
  const auto in_forwarding_index = TrainingOperandIndex{in_index, true};
  insertUse(in_forwarding_index, backwarding_op_index);
 
  const auto &weights_index = node.getInputs().at(train::operation::Conv2D::Input::KERNEL);
  const auto weights_forwarding_index = TrainingOperandIndex{weights_index, true};
  insertUse(weights_forwarding_index, backwarding_op_index);
 
  // Insert use of forwarding output
  if (node.param().activation != ir::Activation::NONE)
  {
    const auto &out_index = node.getOutputs().at(0);
    const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
    insertUse(out_forwarding_index, backwarding_op_index);
  }
 
  // Set def of backwarding inputs
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
 
  const auto weights_gradient_index = TrainingOperandIndex{weights_index, false};
  insertDef(weights_gradient_index, backwarding_op_index);
 
  const auto &bias_index = node.getInputs().at(ir::operation::Conv2D::Input::BIAS);
  if (bias_index.valid())
  {
    const auto bias_gradient_index = TrainingOperandIndex{bias_index, false};
    insertDef(bias_gradient_index, backwarding_op_index);
  }
}

References onert::ir::operation::Conv2D::Param::activation, onert::ir::OperandIndexSequence::at(), onert::ir::operation::Conv2D::BIAS, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Conv2D::INPUT, onert::ir::operation::Conv2D::KERNEL, onert::ir::NONE, and onert::ir::operation::Conv2D::param().

visit() [3/11]

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

override

Definition at line 138 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of forwarding inputs
  const auto &in_index = node.getInputs().at(train::operation::DepthwiseConv2D::Input::INPUT);
  const auto in_forwarding_index = TrainingOperandIndex{in_index, true};
  insertUse(in_forwarding_index, backwarding_op_index);
 
  const auto &weights_index = node.getInputs().at(train::operation::DepthwiseConv2D::Input::KERNEL);
  const auto weights_forwarding_index = TrainingOperandIndex{weights_index, true};
  insertUse(weights_forwarding_index, backwarding_op_index);
 
  // Insert uses of forwarding output
  if (node.param().activation != ir::Activation::NONE)
  {
    const auto &out_index = node.getOutputs().at(0);
    const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
    insertUse(out_forwarding_index, backwarding_op_index);
  }
 
  // Set def of backwarding inputs
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
 
  const auto weights_gradient_index = TrainingOperandIndex{weights_index, false};
  insertDef(weights_gradient_index, backwarding_op_index);
 
  const auto &bias_index = node.getInputs().at(ir::operation::Conv2D::Input::BIAS);
  if (bias_index.valid())
  {
    const auto bias_gradient_index = TrainingOperandIndex{bias_index, false};
    insertDef(bias_gradient_index, backwarding_op_index);
  }
}

References onert::ir::operation::DepthwiseConv2D::Param::activation, onert::ir::OperandIndexSequence::at(), onert::ir::operation::Conv2D::BIAS, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::DepthwiseConv2D::INPUT, onert::ir::operation::DepthwiseConv2D::KERNEL, onert::ir::NONE, and onert::ir::operation::DepthwiseConv2D::param().

visit() [4/11]

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

override

Definition at line 176 of file UseDefGenerator.cc.

{
  if (node.param().op_type != operation::ElementwiseActivation::Type::RELU)
  {
    throw std::runtime_error{"UseDefGenerator: Not yet supported activation type"};
  }
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of forwarding output
  const auto &out_index = node.getOutputs().at(0);
  const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
  insertUse(out_forwarding_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) inputs
  for (const auto &in_index : node.getInputs() | ir::Remove::UNDEFINED | ir::Remove::DUPLICATED)
  {
    const auto outgoing_index = TrainingOperandIndex{in_index, false};
    insertBackPropDef(outgoing_index, backwarding_op_index);
  }
}

References onert::ir::OperandIndexSequence::at(), onert::ir::DUPLICATED, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::ElementwiseActivation::Param::op_type, onert::ir::operation::ElementwiseActivation::param(), onert::ir::operation::ElementwiseActivation::RELU, and onert::ir::UNDEFINED.

visit() [5/11]

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

override

Definition at line 199 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of forwarding inputs
  const auto &in_index = node.getInputs().at(train::operation::FullyConnected::Input::INPUT);
  const auto in_forwarding_index = TrainingOperandIndex{in_index, true};
  insertUse(in_forwarding_index, backwarding_op_index);
 
  const auto &weights_index = node.getInputs().at(train::operation::FullyConnected::Input::WEIGHT);
  const auto weights_forwarding_index = TrainingOperandIndex{weights_index, true};
  insertUse(weights_forwarding_index, backwarding_op_index);
 
  // Insert uses of forwarding output
  if (node.param().activation != ir::Activation::NONE)
  {
    const auto &out_index = node.getOutputs().at(0);
    const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
    insertUse(out_forwarding_index, backwarding_op_index);
  }
 
  // Set def of backwarding inputs
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
 
  const auto weights_gradient_index = TrainingOperandIndex{weights_index, false};
  insertDef(weights_gradient_index, backwarding_op_index);
 
  const auto &bias_index = node.getInputs().at(ir::operation::Conv2D::Input::BIAS);
  if (bias_index.valid())
  {
    const auto bias_gradient_index = TrainingOperandIndex{bias_index, false};
    insertDef(bias_gradient_index, backwarding_op_index);
  }
}

References onert::ir::operation::FullyConnected::Param::activation, onert::ir::OperandIndexSequence::at(), onert::ir::operation::Conv2D::BIAS, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::FullyConnected::INPUT, onert::ir::NONE, onert::ir::operation::FullyConnected::param(), and onert::ir::operation::FullyConnected::WEIGHT.

visit() [6/11]

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

override

Definition at line 237 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  for (const auto &in_index : node.getInputs() | ir::Remove::UNDEFINED | ir::Remove::DUPLICATED)
  {
    // Insert use of forwarding inputs
    const auto in_forwarding_index = TrainingOperandIndex{in_index, true};
    insertUse(in_forwarding_index, backwarding_op_index);
  }
 
  // Set def of backwarding(backprop) y_pred
  const auto &y_pred_index = node.getInputs().at(train::operation::Loss::Input::Y_PRED);
  assert(!_tgraph.operands().at(y_pred_index).isConstant());
  const auto y_pred_outgoing_index = TrainingOperandIndex{y_pred_index, false};
  insertBackPropDef(y_pred_outgoing_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) y_true
  const auto &y_true_index = node.getInputs().at(train::operation::Loss::Input::Y_TRUE);
  assert(!_tgraph.operands().at(y_true_index).isConstant());
  const auto y_true_outgoing_index = TrainingOperandIndex{y_true_index, false};
  insertBackPropDef(y_true_outgoing_index, backwarding_op_index);
 
  // Remove use of backwarding output
  const auto &out_index = node.getOutputs().at(0);
  const auto incoming_index = TrainingOperandIndex{out_index, false};
  auto &usedef_chain = _training_usedefs.at(incoming_index);
  usedef_chain.removeTrainingUse(backwarding_op_index);
}

References onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), onert::ir::DUPLICATED, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::train::TrainableGraph::operands(), onert::ir::UNDEFINED, onert::ir::operation::Loss::Y_PRED, and onert::ir::operation::Loss::Y_TRUE.

visit() [7/11]

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

override

Definition at line 269 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of forwarding pad
  const auto &pad_index = node.getInputs().at(train::operation::Pad::Input::PAD);
  const auto pad_forwarding_index = TrainingOperandIndex{pad_index, true};
  insertUse(pad_forwarding_index, backwarding_op_index);
 
  // Insert use of backwarding(backprop) output
  const auto &out_index = node.getOutputs().at(0);
  const auto incoming_index = TrainingOperandIndex{out_index, false};
  insertUse(incoming_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) input
  const auto &in_index = node.getInputs().at(train::operation::Pad::Input::INPUT);
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Pad::INPUT, and onert::ir::operation::Pad::PAD.

visit() [8/11]

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

override

Definition at line 291 of file UseDefGenerator.cc.

{
  if (node.param().op_type != ir::operation::Pool2D::PoolType::MAX &&
      node.param().op_type != ir::operation::Pool2D::PoolType::AVG)
  {
    throw std::runtime_error{"UseDefGenerator: Not yet supported pool type"};
  }
 
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert uses of forwarding output
  if (node.param().activation != ir::Activation::NONE)
  {
    const auto &out_index = node.getOutputs().at(0);
    const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
    insertUse(out_forwarding_index, backwarding_op_index);
  }
 
  // Insert use of backwarding(backprop) output
  const auto &out_index = node.getOutputs().at(0);
  const auto incoming_index = TrainingOperandIndex{out_index, false};
  insertUse(incoming_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) input
  const auto &in_index = node.getInputs().at(train::operation::Pool2D::Input::INPUT);
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
}

References onert::ir::operation::Pool2D::Param::activation, onert::ir::OperandIndexSequence::at(), onert::ir::operation::Pool2D::AVG, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Pool2D::INPUT, onert::ir::operation::Pool2D::MAX, onert::ir::NONE, onert::ir::operation::Pool2D::Param::op_type, and onert::ir::operation::Pool2D::param().

visit() [9/11]

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

override

Definition at line 322 of file UseDefGenerator.cc.

{
  if (node.param().reduce_type != ir::operation::Reduce::ReduceType::MEAN)
  {
    throw std::runtime_error{"UseDefGenerator: Not yet supported reduce type"};
  }
 
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of backwarding(backprop) output
  const auto &out_index = node.getOutputs().at(0);
  const auto incoming_index = TrainingOperandIndex{out_index, false};
  insertUse(incoming_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) input
  const auto &in_index = node.getInputs().at(train::operation::Reduce::Input::INPUT);
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Reduce::INPUT, onert::ir::operation::Reduce::MEAN, onert::ir::operation::Reduce::param(), and onert::ir::operation::Reduce::Param::reduce_type.

visit() [10/11]

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

override

Definition at line 344 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert use of backwarding(backprop) output
  const auto &out_index = node.getOutputs().at(0);
  const auto incoming_index = TrainingOperandIndex{out_index, false};
  insertUse(incoming_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) input
  const auto &in_index = node.getInputs().at(train::operation::Reduce::Input::INPUT);
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), and onert::ir::operation::Reduce::INPUT.

visit() [11/11]

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

override

Definition at line 361 of file UseDefGenerator.cc.

{
  assert(_node_to_idx.find(&node) != _node_to_idx.end());
  const auto &op_index = _node_to_idx.at(&node);
  const auto backwarding_op_index = TrainingOperationIndex{op_index, false};
 
  // Insert uses of forwarding output
  const auto &out_index = node.getOutputs().at(0);
  const auto out_forwarding_index = TrainingOperandIndex{out_index, true};
  insertUse(out_forwarding_index, backwarding_op_index);
 
  // Insert use of backwarding(backprop) output
  const auto incoming_index = TrainingOperandIndex{out_index, false};
  insertUse(incoming_index, backwarding_op_index);
 
  // Set def of backwarding(backprop) input
  const auto &in_index = node.getInputs().at(train::operation::Reduce::Input::INPUT);
  const auto outgoing_index = TrainingOperandIndex{in_index, false};
  insertBackPropDef(outgoing_index, backwarding_op_index);
}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), and onert::ir::operation::Reduce::INPUT.

---

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

• runtime/onert/core/src/ir/train/UseDefGenerator.h
• runtime/onert/core/src/ir/train/UseDefGenerator.cc