nnc::SinkTranspose Class Reference

This pass sinks transposes below Relu and Concat nodes (in that order). ‘concat(relu(tr(x)), relu(tr(y))) -> tr(concat’(relu(x), relu(y)))`. More...

#include <SinkTranspose.h>

Collaboration diagram for nnc::SinkTranspose:

Public Member Functions
PassData	run (PassData data) override
	run compiler pass
std::string	getName () override
Public Member Functions inherited from nnc::Pass
virtual void	cleanup ()
	clean compiler pass data
virtual	~Pass ()=default

Detailed Description

This pass sinks transposes below Relu and Concat nodes (in that order). ‘concat(relu(tr(x)), relu(tr(y))) -> tr(concat’(relu(x), relu(y)))`.

Definition at line 30 of file SinkTranspose.h.

Member Function Documentation

getName()

std::string nnc::SinkTranspose::getName ( )

inlineoverridevirtual

Reimplemented from nnc::Pass.

Definition at line 35 of file SinkTranspose.h.

{ return "SinkTranspose"; };

run()

PassData nnc::SinkTranspose::run ( PassData  data )

overridevirtual

run compiler pass

Parameters

data	- data that pass is taken

Returns

data that can be passed to the next pass

Exceptions

PassException

object if errors occured

Implements nnc::Pass.

Definition at line 34 of file SinkTranspose.cpp.

{
  auto g = static_cast<Graph *>(data);
  assert(g); // NOLINT
  GraphPatternMatcher matcher(g);
  auto is_tr = [](const Operation *op1) { return op1->getType() == Operation::Type::transpose; };
  auto is_relu = [](const Operation *op2) { return op2->getType() == Operation::Type::ReLU; };
  auto is_concat = [](const Operation *op2) { return op2->getType() == Operation::Type::concat; };
  std::vector<std::pair<Operation *, Operation *>> matches;
 
  // sink transpose below ReLU
  matches = matcher.matchEdge(is_tr, is_relu);
  for (auto pair : matches)
  {
    swapAdjacent(g, pair.first, pair.second);
  }
 
  // sink transpose through Concat
  auto v_matches = matcher.matchUpBush(is_tr, is_concat);
  for (const auto &pair : v_matches)
  {
    std::vector<Operation *> trs = pair.first;
    auto *concat = dynamic_cast<ops::ConcatOp *>(pair.second);
    auto axis_order = dynamic_cast<ops::TransposeOp *>(trs[0])->getAxisOrder();
    if (std::all_of(trs.begin(), trs.end(), [&axis_order](Operation *tr) {
          return dynamic_cast<ops::TransposeOp *>(tr)->getAxisOrder() == axis_order;
        }))
    {
      std::vector<Operation::Output *> prev_trans;
      prev_trans.reserve(trs.size());
      for (auto transpose : trs)
      {
        prev_trans.emplace_back(transpose->getInput(0));
      }
      auto new_concat = g->create<ops::ConcatOp>(prev_trans, axis_order[concat->getAxis()]);
      auto new_transpose = g->create<ops::TransposeOp>(new_concat->getOutput(0), axis_order);
      // removes old concat
      g->replaceNode(concat, new_transpose);
      for (auto tr : trs)
      {
        removeNodeIfUnused(g, tr);
      }
    }
  }
 
  return g;
}

References mir::GraphPatternMatcher::matchEdge(), mir::GraphPatternMatcher::matchUpBush(), nnc::opt_util::removeNodeIfUnused(), and nnc::opt_util::swapAdjacent().

Referenced by package.infer.session::inference().

---

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

• compiler/nnc/include/passes/optimizations/SinkTranspose.h
• compiler/nnc/passes/optimizations/SinkTranspose.cpp