onert::ir::train::TrainableGraph Class Reference

#include <TrainableGraph.h>

Collaboration diagram for onert::ir::train::TrainableGraph:

Public Member Functions
	TrainableGraph ()
	Construct a new Trainable Graph object.
	TrainableGraph (const TrainableGraph &tgraph)
	TrainableGraph (const Graph &graph)
	~TrainableGraph ()=default
OperandIndex	addOperand (const Shape &shape, const TypeInfo &type)
OperandIndex	addOperand (OperandIndex index, std::unique_ptr< Operand > &&operand)
	Add an operand to the graph with the given index and object.
OperationIndex	addOperation (std::unique_ptr< ITrainableOperation > &&operation)
	Add a new trainable operation to the graph.
OperationIndex	replaceOperation (OperationIndex index, std::unique_ptr< ITrainableOperation > &&operation)
	Replace a trainable operation which the graph already has.
OperandIndex	addBackwardOperand (OperandIndex index, std::unique_ptr< Operand > &&bwd_operand)
	Add an operand for backwarding to the graph with the given index and object.
void	changeShape (const OperandIndex &ind, const ir::Shape &new_shape) override
void	changeBackwardShape (const OperandIndex &ind, const ir::Shape &new_shape)
void	addInput (const OperandIndex &ind, const std::string &name="")
void	addOutput (const OperandIndex &ind, const std::string &name="")
void	addLoss (const OperandIndex &loss_ind, const IOIndex &pred_io_ind)
void	verify () const
void	removeOperand (const OperandIndex &ind)
void	setInputs (OperandIndexSequence inputs, std::unordered_map< std::string, IOIndex > name_to_input)
void	setOutputs (OperandIndexSequence outputs, std::unordered_map< std::string, IOIndex > name_to_output)
void	enableBackward (const OperationIndex &index)
void	disableBackward (const OperationIndex &index)
void	setTrainingUseDefs (const UseDefChains &training_defuses)
const OperandIndexSequence &	getInputs () const override
const OperandIndexSequence &	getOutputs () const override
IOIndex	getInputIndex (const std::string &name) const override
IOIndex	getOutputIndex (const std::string &name) const override
const Operands &	operands () const override
Operands &	operands ()
const Operations &	operations () const override
const Operands &	backward_operands () const
OperandIndex	getLossIndex (const IOIndex &pred_io_ind) const
const Graph &	graph () const
const ITrainableOperation &	operation (OperationIndex index) const
const UseDefChains &	trainingUseDefs () const
std::vector< ir::OperationIndex >	topolSortOperations () const
std::vector< ir::OperationIndex >	btopolSortOperations () const
std::vector< ir::OperationIndex >	essentialBackwardOrder () const
std::vector< ir::OperationIndex >	truncateBackwardOrder (const std::vector< ir::OperationIndex > &backward_order) const
	Truncate the backward order of operations in accordance with the alive condition whether the corresponding operation has trainable parameters.
std::vector< ir::OperationIndex >	truncateBackwardOrder (std::vector< ir::OperationIndex > backward_order, std::function< bool(const ir::OperationIndex &)> truncating_cond) const
	Truncate the backward order of operations in accordance with the given alive condition.
void	updateGraphDependency ()
Public Member Functions inherited from onert::ir::IGraph
virtual	~IGraph ()=default

Detailed Description

Definition at line 31 of file TrainableGraph.h.

Constructor & Destructor Documentation

TrainableGraph() [1/3]

onert::ir::train::TrainableGraph::TrainableGraph ( )

explicit

Construct a new Trainable Graph object.

Parameters

graph

Definition at line 78 of file TrainableGraph.cc.

: _graph{} {}

TrainableGraph() [2/3]

onert::ir::train::TrainableGraph::TrainableGraph ( const TrainableGraph &  tgraph )

explicit

Definition at line 80 of file TrainableGraph.cc.

  : _graph{tgraph._graph}, _backward_operands{tgraph._backward_operands},
    _training_defuses{tgraph._training_defuses}, _losses{tgraph._losses}
{
  tgraph.operations().iterate(
    [&](const onert::ir::OperationIndex &index, const onert::ir::IOperation &op) {
      replaceOperation(index, dynamic_cast<const ITrainableOperation &>(op).clone());
    });
}

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

TrainableGraph() [3/3]

onert::ir::train::TrainableGraph::TrainableGraph ( const Graph &  graph )

explicit

Definition at line 90 of file TrainableGraph.cc.

: _graph{graph} {}

~TrainableGraph()

onert::ir::train::TrainableGraph::~TrainableGraph ( )

default

Member Function Documentation

addBackwardOperand()

OperandIndex onert::ir::train::TrainableGraph::addBackwardOperand	(	OperandIndex	index,
		std::unique_ptr< Operand > &&	bwd_operand
	)

Add an operand for backwarding to the graph with the given index and object.

If the given index is available, it succeeds. And bwd_operand is moved which invalidates the caller's pointer. If the given index is already taken, it fails. And bwd_operand will not be moved so the caller's pointer will be still valid.

Parameters

[in]	index	Index to be added
[in]	bwd_operand	Backward operand to be added

Returns

OperandIndex index if successful, UNDEFINED otherwise

Definition at line 113 of file TrainableGraph.cc.

{
  return _backward_operands.push(std::move(bwd_operand), index);
}

References onert::util::ObjectManager< Index, Object >::push().

addInput()

void onert::ir::train::TrainableGraph::addInput	(	const OperandIndex &	ind,
		const std::string &	name = ""
	)

Definition at line 140 of file TrainableGraph.cc.

{
  _graph.addInput(ind, name);
}

References onert::ir::Graph::addInput().

Referenced by onert::compiler::train::pass::LossInsertionPass::run().

addLoss()

void onert::ir::train::TrainableGraph::addLoss	(	const OperandIndex &	loss_ind,
		const IOIndex &	pred_io_ind
	)

Definition at line 365 of file TrainableGraph.cc.

{
  _losses.emplace(pred_ioind, loss_ind);
}

Referenced by onert::compiler::train::pass::LossInsertionPass::run().

addOperand() [1/2]

OperandIndex onert::ir::train::TrainableGraph::addOperand	(	const Shape &	shape,
		const TypeInfo &	type
	)

Definition at line 92 of file TrainableGraph.cc.

{
  return _graph.addOperand(shape, type);
}

References onert::ir::Graph::addOperand().

Referenced by onert::compiler::train::pass::LossInsertionPass::run().

addOperand() [2/2]

OperandIndex onert::ir::train::TrainableGraph::addOperand	(	OperandIndex	index,
		std::unique_ptr< Operand > &&	operand
	)

Add an operand to the graph with the given index and object.

If the given index is available, it succeeds. And operand is moved which invalidates the caller's pointer. If the given index is already taken, it fails. And operand will not be moved so the caller's pointer will be still valid.

Parameters

[in]	index	Index to be added
[in]	operand	Operand to be added

Returns

OperandIndex index if successful, UNDEFINED otherwise

Definition at line 97 of file TrainableGraph.cc.

{
  return _graph.addOperand(index, std::move(operand));
}

References onert::ir::Graph::addOperand().

addOperation()

OperationIndex onert::ir::train::TrainableGraph::addOperation

(

std::unique_ptr< ITrainableOperation > &&

operation

)

Add a new trainable operation to the graph.

If the given operation has at least one invalid operand index, it fails. And operation will not be moved so the caller's pointer will be still valid.

Parameters

operation

Operation to be added

Returns

OperationIndex index if successful, UNDEFINED otherwise

Definition at line 102 of file TrainableGraph.cc.

{
  return _graph.addOperation(std::move(operation));
}

References onert::ir::Graph::addOperation(), and operation().

Referenced by onert::compiler::train::pass::LossInsertionPass::run().

addOutput()

void onert::ir::train::TrainableGraph::addOutput	(	const OperandIndex &	ind,
		const std::string &	name = ""
	)

Definition at line 145 of file TrainableGraph.cc.

{
  _graph.addOutput(ind, name);
}

References onert::ir::Graph::addOutput().

backward_operands()

const Operands & onert::ir::train::TrainableGraph::backward_operands ( ) const

inline

Definition at line 122 of file TrainableGraph.h.

{ return _backward_operands; }

btopolSortOperations()

std::vector< ir::OperationIndex > onert::ir::train::TrainableGraph::btopolSortOperations

(

)

const

Definition at line 271 of file TrainableGraph.cc.

{
  std::vector<ir::OperationIndex> ret;
  util::Set<ir::OperationIndex> unvisited;
  ir::OperationIndex loss_idx;
  operations().iterate([&](const ir::OperationIndex &index, const ir::IOperation &op) {
    unvisited.add(index);
    if (op.opcode() == ir::OpCode::Loss)
    {
      assert(!loss_idx.valid()); // Should be only one loss
      loss_idx = index;
    }
  });
 
  std::function<void(const ir::OperationIndex &, const ir::IOperation &)> dfs =
    [&](const ir::OperationIndex &index, const ir::IOperation &op) -> void {
    if (!unvisited.contains(index))
      return;
    unvisited.remove(index);
 
    for (const auto &input : op.getInputs() | ir::Remove::DUPLICATED | ir::Remove::UNDEFINED)
    {
      const auto &operand = operands().at(input);
      const auto &def = operand.getDef();
      if (!def.valid())
        continue;
      dfs(def, operations().at(def));
    }
 
    ret.push_back(index);
  };
 
  dfs(loss_idx, operations().at(loss_idx));
  std::reverse(ret.begin(), ret.end());
  validateBackwardTopologicalOrder(ret);
 
  return ret;
}

References onert::util::Set< Element >::add(), onert::util::ObjectManager< Index, Object >::at(), onert::util::Set< Element >::contains(), onert::ir::DUPLICATED, onert::ir::Operand::getDef(), onert::ir::IOperation::getInputs(), onert::util::ObjectManager< Index, Object >::iterate(), onert::ir::IOperation::opcode(), operands(), operations(), onert::util::Set< Element >::remove(), and onert::ir::UNDEFINED.

Referenced by essentialBackwardOrder().

changeBackwardShape()

void onert::ir::train::TrainableGraph::changeBackwardShape	(	const OperandIndex &	ind,
		const ir::Shape &	new_shape
	)

Definition at line 134 of file TrainableGraph.cc.

{
  assert(_backward_operands.exist(index));
  _backward_operands.at(index).info().shape(new_shape);
}

References onert::util::ObjectManager< Index, Object >::at(), onert::util::ObjectManager< Index, Object >::exist(), onert::ir::Operand::info(), and onert::ir::OperandInfo::shape().

changeShape()

void onert::ir::train::TrainableGraph::changeShape ( const OperandIndex &  ind, const ir::Shape &  new_shape  )

overridevirtual

Implements onert::ir::IGraph.

Definition at line 129 of file TrainableGraph.cc.

{
  _graph.changeShape(index, new_shape);
}

References onert::ir::Graph::changeShape().

disableBackward()

void onert::ir::train::TrainableGraph::disableBackward

(

const OperationIndex &

index

)

Definition at line 184 of file TrainableGraph.cc.

{
  auto &op = dynamic_cast<ir::train::ITrainableOperation &>(_graph.operations().at(index));
  op.disableBackward();
}

References onert::util::ObjectManager< Index, Object >::at(), onert::ir::train::ITrainableOperation::disableBackward(), and onert::ir::Graph::operations().

enableBackward()

void onert::ir::train::TrainableGraph::enableBackward

(

const OperationIndex &

index

)

Definition at line 177 of file TrainableGraph.cc.

{
  auto op = dynamic_cast<ir::train::ITrainableOperation *>(&_graph.operations().at(index));
  assert(op);
  op->enableBackward();
}

References onert::util::ObjectManager< Index, Object >::at(), and onert::ir::Graph::operations().

essentialBackwardOrder()

std::vector< ir::OperationIndex > onert::ir::train::TrainableGraph::essentialBackwardOrder

(

)

const

Definition at line 310 of file TrainableGraph.cc.

{
  auto backward_order = btopolSortOperations();
  // get rid of all nodes not reachable from a node with trainable parameters
  backward_order = truncateBackwardOrder(backward_order, [&](const OperationIndex &index) {
    return operation(index).isRequiredForBackward();
  });
 
  return truncateBackwardOrder(backward_order);
}

References btopolSortOperations(), onert::ir::train::ITrainableOperation::isRequiredForBackward(), operation(), and truncateBackwardOrder().

Referenced by onert::backend::train::TensorPlanner::planBackPropTensors(), onert::backend::train::TensorPlanner::planDisposableBackPropTensors(), onert::backend::train::TensorPlanner::planGradientTensors(), onert::backend::train::TensorPlanner::planLayerScopeTensors(), and onert::backend::train::TensorPlanner::planNonConstTensors().

getInputIndex()

IOIndex onert::ir::train::TrainableGraph::getInputIndex ( const std::string &  name ) const

overridevirtual

Implements onert::ir::IGraph.

Definition at line 119 of file TrainableGraph.cc.

{
  return _graph.getInputIndex(name);
}

References onert::ir::Graph::getInputIndex().

getInputs()

const OperandIndexSequence & onert::ir::train::TrainableGraph::getInputs ( ) const

inlineoverridevirtual

Implements onert::ir::IGraph.

Definition at line 115 of file TrainableGraph.h.

{ return _graph.getInputs(); }

References onert::ir::Graph::getInputs().

Referenced by onert::exec::train::TrainableExecutor::TrainableExecutor().

getLossIndex()

OperandIndex onert::ir::train::TrainableGraph::getLossIndex

(

const IOIndex &

pred_io_ind

)

const

Definition at line 370 of file TrainableGraph.cc.

{
  auto itr = _losses.find(pred_ioind);
  return (itr == _losses.end()) ? OperandIndex{} : itr->second;
}

Referenced by onert::exec::train::TrainableExecutor::getLoss().

getOutputIndex()

IOIndex onert::ir::train::TrainableGraph::getOutputIndex ( const std::string &  name ) const

overridevirtual

Implements onert::ir::IGraph.

Definition at line 124 of file TrainableGraph.cc.

{
  return _graph.getOutputIndex(name);
}

References onert::ir::Graph::getOutputIndex().

getOutputs()

const OperandIndexSequence & onert::ir::train::TrainableGraph::getOutputs ( ) const

inlineoverridevirtual

Implements onert::ir::IGraph.

Definition at line 116 of file TrainableGraph.h.

{ return _graph.getOutputs(); }

References onert::ir::Graph::getOutputs().

Referenced by onert::compiler::train::pass::LossInsertionPass::run(), and onert::exec::train::TrainableExecutor::TrainableExecutor().

graph()

const Graph & onert::ir::train::TrainableGraph::graph ( ) const

inline

Definition at line 124 of file TrainableGraph.h.

{ return _graph; }

Referenced by TopologicalSortHelper.TopologicalSortHelper::add_edge(), onert::exec::train::TrainableExecutor::graph(), onert::compiler::train::LoweredTrainableGraph::graph(), onert::compiler::train::LoweredTrainableGraph::graph(), onert::ir::train::UseDefGenerator::operator()(), and TopologicalSortHelper.TopologicalSortHelper::sort_util().

operands() [1/2]

Operands & onert::ir::train::TrainableGraph::operands ( )

inline

Definition at line 120 of file TrainableGraph.h.

{ return _graph.operands(); } // TODO Remove this non-const accessor

References onert::ir::Graph::operands().

operands() [2/2]

const Operands & onert::ir::train::TrainableGraph::operands ( ) const

inlineoverridevirtual

Implements onert::ir::IGraph.

Definition at line 119 of file TrainableGraph.h.

{ return _graph.operands(); }

References onert::ir::Graph::operands().

Referenced by btopolSortOperations(), onert::backend::train::BackendContext::gen(), onert::backend::builtin::train::BackendContext::gen(), onert::backend::basic::train::genTensors(), onert::backend::train::TensorPlanner::planBackPropTensors(), onert::compiler::train::pass::LossInsertionPass::run(), truncateBackwardOrder(), onert::backend::train::KernelGenerator::visit(), onert::backend::train::KernelGenerator::visit(), onert::backend::train::KernelGenerator::visit(), and onert::ir::train::UseDefGenerator::visit().

operation()

const ITrainableOperation & onert::ir::train::TrainableGraph::operation

(

OperationIndex

index

)

const

Definition at line 171 of file TrainableGraph.cc.

{
  // NOTE Virtual inherited objects cannot be static_casted.
  return dynamic_cast<const ITrainableOperation &>(_graph.operations().at(index));
}

References onert::util::ObjectManager< Index, Object >::at(), and onert::ir::Graph::operations().

Referenced by addOperation(), essentialBackwardOrder(), onert::backend::builtin::train::KernelGenerator::generate(), onert::backend::train::KernelGenerator::generate(), onert::compiler::train::StaticBackwardShapeInferer::infer(), onert::backend::train::TensorPlanner::planDisposableBackPropTensors(), replaceOperation(), truncateBackwardOrder(), and onert::ir::train::UseDefGenerator::UseDefGenerator().

operations()

const Operations & onert::ir::train::TrainableGraph::operations ( ) const

inlineoverridevirtual

Implements onert::ir::IGraph.

Definition at line 121 of file TrainableGraph.h.

{ return _graph.operations(); }

References onert::ir::Graph::operations().

Referenced by btopolSortOperations(), onert::backend::train::KernelGenerator::KernelGenerator(), onert::backend::train::TensorPlanner::planBackPropTensors(), onert::backend::train::TensorPlanner::planGradientTensors(), onert::backend::train::TensorPlanner::planNonConstTensors(), onert::compiler::train::pass::LossInsertionPass::run(), TrainableGraph(), truncateBackwardOrder(), and verify().

removeOperand()

void onert::ir::train::TrainableGraph::removeOperand

(

const OperandIndex &

ind

)

Definition at line 169 of file TrainableGraph.cc.

{ _graph.removeOperand(ind); }

References onert::ir::Graph::removeOperand().

replaceOperation()

OperationIndex onert::ir::train::TrainableGraph::replaceOperation	(	OperationIndex	index,
		std::unique_ptr< ITrainableOperation > &&	operation
	)

Replace a trainable operation which the graph already has.

If the given index is available, it succeeds. And operation is moved which invalidates the caller's pointer. If the given operation has at least one invalid operand index, it fails. And operation will not be moved so the caller's pointer will be still valid.

No information in the graph is changed except for replacing an operation.

Parameters

operation

Operation to be added

Returns

OperationIndex index if successful, UNDEFINED otherwise

Definition at line 107 of file TrainableGraph.cc.

{
  return _graph.replaceOperation(index, std::move(operation));
}

References operation(), and onert::ir::Graph::replaceOperation().

Referenced by TrainableGraph().

setInputs()

void onert::ir::train::TrainableGraph::setInputs	(	OperandIndexSequence	inputs,
		std::unordered_map< std::string, IOIndex >	name_to_input
	)

setOutputs()

void onert::ir::train::TrainableGraph::setOutputs	(	OperandIndexSequence	outputs,
		std::unordered_map< std::string, IOIndex >	name_to_output
	)

setTrainingUseDefs()

void onert::ir::train::TrainableGraph::setTrainingUseDefs

(

const UseDefChains &

training_defuses

)

Definition at line 190 of file TrainableGraph.cc.

{
  _training_defuses.clear();
  // TODO Replace this loop with `std::unordered_map::insert_range` since C++23
  for (const auto &[training_index, usedef] : training_defuses)
  {
    _training_defuses.emplace(training_index, usedef);
  }
}

Referenced by updateGraphDependency().

topolSortOperations()

std::vector< ir::OperationIndex > onert::ir::train::TrainableGraph::topolSortOperations

(

)

const

Definition at line 263 of file TrainableGraph.cc.

{
  auto ret = _graph.topolSortOperations();
  validateForwardTopologicalOrder(ret);
 
  return ret;
}

References onert::ir::Graph::topolSortOperations().

Referenced by onert::backend::train::TensorPlanner::planLayerScopeTensors(), onert::backend::train::TensorPlanner::planNonConstTensors(), and onert::ir::train::UseDefGenerator::UseDefGenerator().

trainingUseDefs()

const UseDefChains & onert::ir::train::TrainableGraph::trainingUseDefs ( ) const

inline

Definition at line 128 of file TrainableGraph.h.

{ return _training_defuses; }

Referenced by onert::backend::train::TensorPlanner::planBackPropTensors(), onert::backend::train::TensorPlanner::planGradientTensors(), onert::backend::train::TensorPlanner::planNonConstTensors(), and onert::backend::train::TensorPlanner::planTrainableTensors().

truncateBackwardOrder() [1/2]

std::vector< ir::OperationIndex > onert::ir::train::TrainableGraph::truncateBackwardOrder

(

const std::vector< ir::OperationIndex > &

backward_order

)

const

Truncate the backward order of operations in accordance with the alive condition whether the corresponding operation has trainable parameters.

Parameters

backward_order

The order of operations in a backward graph

Definition at line 356 of file TrainableGraph.cc.

{
  return truncateBackwardOrder(backward_order, [&](const ir::OperationIndex &index) {
    const auto &trainable_op = operation(index);
 
    return trainable_op.hasTrainableParameter();
  });
}

References operation(), and truncateBackwardOrder().

Referenced by essentialBackwardOrder(), and truncateBackwardOrder().

truncateBackwardOrder() [2/2]

std::vector< ir::OperationIndex > onert::ir::train::TrainableGraph::truncateBackwardOrder	(	std::vector< ir::OperationIndex >	backward_order,
		std::function< bool(const ir::OperationIndex &)>	truncating_cond
	)		const

Truncate the backward order of operations in accordance with the given alive condition.

Parameters

backward_order	The order of operations in a backward graph
alive_cond	The alive condition to stop the backward order

Definition at line 321 of file TrainableGraph.cc.

{
  auto forward_order = backward_order;
  std::reverse(forward_order.begin(), forward_order.end());
  std::set<ir::OperationIndex> alive;
 
  for (const auto &index : forward_order)
  {
    if (alive_cond(index))
      alive.insert(index);
 
    // TODO: replace this with `std::set::contains` after C++20
    if (alive.find(index) != alive.end())
    {
      const auto &op = operations().at(index);
      for (const auto &output : op.getOutputs())
      {
        const auto &operand = operands().at(output);
        for (const auto &use : operand.getUses())
          alive.insert(use);
      }
    }
  }
 
  // TODO: replace this with `std::erase_if(std::vector)` after C++20
  backward_order.erase(
    std::remove_if(backward_order.begin(), backward_order.end(),
                   [&](const auto &index) { return alive.find(index) == alive.end(); }),
    backward_order.end());
  return backward_order;
}

References onert::util::ObjectManager< Index, Object >::at(), onert::ir::IOperation::getOutputs(), operands(), and operations().

updateGraphDependency()

void onert::ir::train::TrainableGraph::updateGraphDependency

(

)

Definition at line 376 of file TrainableGraph.cc.

{
  _graph.verify();
 
  // Initialize training usedefs
  setTrainingUseDefs(UseDefGenerator{*this}());
 
  disableUnusedBackwardNodes(_training_defuses, *this);
 
  verifyTrainingUseDefs();
}

References setTrainingUseDefs(), and onert::ir::Graph::verify().

verify()

void onert::ir::train::TrainableGraph::verify

(

void

)

const

Definition at line 150 of file TrainableGraph.cc.

{
  _graph.verify();
 
  operations().iterate([](const onert::ir::OperationIndex &, const onert::ir::IOperation &op) {
    try
    {
      [[maybe_unused]] const auto &casted_op =
        dynamic_cast<const onert::ir::train::ITrainableOperation &>(op);
    }
    catch (const std::bad_cast &)
    {
      throw std::runtime_error("TrainableGraph: " + op.name() + " is not a trainable operation");
    }
  });
 
  verifyTrainingUseDefs();
}

References onert::util::ObjectManager< Index, Object >::iterate(), onert::ir::IOperation::name(), operations(), and onert::ir::Graph::verify().

---

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

• runtime/onert/core/include/ir/train/TrainableGraph.h
• runtime/onert/core/src/ir/train/TrainableGraph.cc