logo::SimplifyDomainConversionPass Struct Reference

Simplify redundant domain conversion. More...

#include <SimplifyDomainConversionPass.h>

Collaboration diagram for logo::SimplifyDomainConversionPass:

Public Member Functions
const char *	name (void) const final
bool	run (loco::Graph *g) final
	Run the pass.
Public Member Functions inherited from logo::Pass
virtual	~Pass ()=default

Detailed Description

Simplify redundant domain conversion.

SimplifyDomainConversionPass recognizes the following patterns:

• FeatureDecode followed by FeatureEncode (Feature -> Tensor -> Feature)
• FeatureEncode followed by FeatureDecode (Tensor -> Feature -> Tensor)
• FilterEncode followed by FilterDecode (Tensor -> Filter -> Tensor)
• BiasEncode followed by BiasDecode (Tensor -> Bias -> Tensor)
• DepthwiseFilterEncode followed by DepthwiseFilterDecode (Tensor -> DepthwiseFilter -> Tensor)
• MatrixDecode followed by MatrixEncode (Matrix -> Tensor -> Matrix)
• MatrixEncode followed by MatrixDecode (Tensor -> Matrix -> Tensor)
• (TO BE ADDED)

Definition at line 38 of file SimplifyDomainConversionPass.h.

Member Function Documentation

name()

const char * logo::SimplifyDomainConversionPass::name ( void  ) const

inlinefinalvirtual

Reimplemented from logo::Pass.

Definition at line 40 of file SimplifyDomainConversionPass.h.

{ return "SimplifyDomainConversionPass"; }

run()

bool logo::SimplifyDomainConversionPass::run ( loco::Graph *  graph )

finalvirtual

Run the pass.

Returns

false if there was nothing changed

Implements logo::Pass.

Definition at line 115 of file SimplifyDomainConversionPass.cpp.

{
  // TODO Introduce and Use "Pattern Match"
  struct Collector final : public loco::CanonicalNodeMutableVisitor<void>
  {
    // Let's find FeatureDecode followed by FeatureEncode
    void visit(loco::FeatureEncode *encode_node) final
    {
      using namespace loco;
 
      auto decode_node = dynamic_cast<loco::FeatureDecode *>(encode_node->input());
      if (decode_node == nullptr)
      {
        return;
      }
      assert(decode_node->input() != nullptr);
 
      auto encoder = encode_node->encoder();
      assert(encoder != nullptr);
 
      auto decoder = decode_node->decoder();
      assert(decoder != nullptr);
 
      // NOTE Work only for permuting codec
      auto perm_decoder = dynamic_cast<const PermutingDecoder<Domain::Feature> *>(decoder);
      auto perm_encoder = dynamic_cast<const PermutingEncoder<Domain::Feature> *>(encoder);
 
      if (perm_encoder == nullptr || perm_decoder == nullptr)
      {
        return;
      }
 
      if (equal(perm_encoder->perm(), perm_decoder->perm()))
      {
        forwardCandidates.insert({encode_node, decode_node->input()});
      }
    }
 
    // Let's find `FeatureEncode -- FeatureDecode` pattern
    void visit(loco::FeatureDecode *decode_node) final
    {
      using namespace loco;
 
      auto encode_node = dynamic_cast<loco::FeatureEncode *>(decode_node->input());
      if (encode_node == nullptr)
      {
        return;
      }
      assert(encode_node->input() != nullptr);
 
      auto encoder = encode_node->encoder();
      assert(encoder != nullptr);
 
      auto decoder = decode_node->decoder();
      assert(decoder != nullptr);
 
      // NOTE Work only for permuting codec
      auto perm_decoder = dynamic_cast<const PermutingDecoder<Domain::Feature> *>(decoder);
      auto perm_encoder = dynamic_cast<const PermutingEncoder<Domain::Feature> *>(encoder);
 
      if (perm_encoder == nullptr || perm_decoder == nullptr)
      {
        return;
      }
 
      if (equal(perm_encoder->perm(), perm_decoder->perm()))
      {
        forwardCandidates.insert({decode_node, encode_node->input()});
      }
    }
 
    // Let's find `FilterEncode -- FilterDecode` pattern
    void visit(loco::FilterDecode *decode_node) final
    {
      using namespace loco;
 
      auto encode_node = dynamic_cast<loco::FilterEncode *>(decode_node->input());
      if (encode_node == nullptr)
      {
        return;
      }
      assert(encode_node->input() != nullptr);
 
      auto encoder = encode_node->encoder();
      assert(encoder != nullptr);
 
      auto decoder = decode_node->decoder();
      assert(decoder != nullptr);
 
      // NOTE Work only for permuting codec
      auto perm_decoder = dynamic_cast<const PermutingDecoder<Domain::Filter> *>(decoder);
      auto perm_encoder = dynamic_cast<const PermutingEncoder<Domain::Filter> *>(encoder);
 
      if (perm_encoder == nullptr || perm_decoder == nullptr)
      {
        return;
      }
 
      if (equal(perm_encoder->perm(), perm_decoder->perm()))
      {
        forwardCandidates.insert({decode_node, encode_node->input()});
      }
      else
      {
        std::vector<loco::TensorAxis> perm_vec;
        perm_vec.resize(4);
 
        auto enc_perm = perm_encoder->perm();
        auto dec_perm = perm_decoder->perm();
 
        for (const auto &axis :
             {FilterAxis::Count, FilterAxis::Height, FilterAxis::Width, FilterAxis::Depth})
        {
          auto from = enc_perm->axis(axis);
          auto to = dec_perm->axis(axis);
          perm_vec[to] = from;
        }
 
        transposeCandidates.insert(
          std::make_unique<TransposeCtx>(encode_node, decode_node, encode_node->input(), perm_vec));
      }
    }
 
    // Let's find `BiasEncode -- BiasDecode` pattern
    void visit(loco::BiasDecode *decode_node) final
    {
      if (auto encode_node = dynamic_cast<loco::BiasEncode *>(decode_node->input()))
      {
        assert(encode_node->input() != nullptr);
        forwardCandidates.insert({decode_node, encode_node->input()});
      }
    }
 
    // Let's find `DepthwiseFilterEncode -- DepthwiseFilterDecode` pattern
    void visit(loco::DepthwiseFilterDecode *decode_node) final
    {
      using namespace loco;
 
      auto encode_node = dynamic_cast<loco::DepthwiseFilterEncode *>(decode_node->input());
      if (encode_node == nullptr)
      {
        return;
      }
      assert(encode_node->input() != nullptr);
 
      auto encoder = encode_node->encoder();
      assert(encoder != nullptr);
 
      auto decoder = decode_node->decoder();
      assert(decoder != nullptr);
 
      // NOTE Work only for permuting codec
      auto perm_decoder = dynamic_cast<const PermutingDecoder<Domain::DepthwiseFilter> *>(decoder);
      auto perm_encoder = dynamic_cast<const PermutingEncoder<Domain::DepthwiseFilter> *>(encoder);
 
      if (perm_encoder == nullptr || perm_decoder == nullptr)
      {
        return;
      }
 
      if (equal(perm_encoder->perm(), perm_decoder->perm()))
      {
        forwardCandidates.insert({decode_node, encode_node->input()});
      }
      else
      {
        std::vector<TensorAxis> perm_vec;
        perm_vec.resize(4);
 
        auto enc_perm = perm_encoder->perm();
        auto dec_perm = perm_decoder->perm();
 
        for (const auto &axis : {DepthwiseFilterAxis::Depth, DepthwiseFilterAxis::Height,
                                 DepthwiseFilterAxis::Width, DepthwiseFilterAxis::Multiplier})
        {
          auto from = enc_perm->axis(axis);
          auto to = dec_perm->axis(axis);
          perm_vec[to] = from;
        }
 
        transposeCandidates.insert(
          std::make_unique<TransposeCtx>(encode_node, decode_node, encode_node->input(), perm_vec));
      }
    }
 
    // Let's find MatrixDecode followed by MatrixEncode
    void visit(loco::MatrixEncode *encode_node) final
    {
      using namespace loco;
 
      auto decode_node = dynamic_cast<loco::MatrixDecode *>(encode_node->input());
      if (decode_node == nullptr)
      {
        return;
      }
      assert(decode_node->input() != nullptr);
 
      auto encoder = encode_node->encoder();
      assert(encoder != nullptr);
 
      auto decoder = decode_node->decoder();
      assert(decoder != nullptr);
 
      // NOTE Work only for permuting codec
      auto perm_decoder = dynamic_cast<const PermutingDecoder<Domain::Matrix> *>(decoder);
      auto perm_encoder = dynamic_cast<const PermutingEncoder<Domain::Matrix> *>(encoder);
 
      if (perm_encoder == nullptr || perm_decoder == nullptr)
      {
        return;
      }
 
      if (equal(perm_encoder->perm(), perm_decoder->perm()))
      {
        forwardCandidates.insert({encode_node, decode_node->input()});
      }
    }
 
    // Let's find MatrixEncode followed by MatrixDecode
    void visit(loco::MatrixDecode *decode_node) final
    {
      using namespace loco;
 
      auto encode_node = dynamic_cast<loco::MatrixEncode *>(decode_node->input());
      if (encode_node == nullptr)
      {
        return;
      }
      assert(encode_node->input() != nullptr);
 
      auto encoder = encode_node->encoder();
      assert(encoder != nullptr);
 
      auto decoder = decode_node->decoder();
      assert(decoder != nullptr);
 
      // NOTE Work only for permuting codec
      auto perm_decoder = dynamic_cast<const PermutingDecoder<Domain::Matrix> *>(decoder);
      auto perm_encoder = dynamic_cast<const PermutingEncoder<Domain::Matrix> *>(encoder);
 
      if (perm_encoder == nullptr || perm_decoder == nullptr)
      {
        return;
      }
 
      if (equal(perm_encoder->perm(), perm_decoder->perm()))
      {
        forwardCandidates.insert({decode_node, encode_node->input()});
      }
      else
      {
        std::vector<loco::TensorAxis> perm_vec;
        perm_vec.resize(2);
 
        auto enc_perm = perm_encoder->perm();
        auto dec_perm = perm_decoder->perm();
 
        for (const auto &axis : {MatrixAxis::Height, MatrixAxis::Width})
        {
          auto from = enc_perm->axis(axis);
          auto to = dec_perm->axis(axis);
          perm_vec[to] = from;
        }
 
        transposeCandidates.insert(
          std::make_unique<TransposeCtx>(encode_node, decode_node, encode_node->input(), perm_vec));
      }
    }
 
    void visit(loco::Node *) final { return; }
 
    using SimplifyingInfo = std::pair<loco::Node * /* end node of subgraph that will be replaced*/,
                                      loco::Node * /* input of subgraph */>;
    std::set<SimplifyingInfo> forwardCandidates;
 
    struct TransposeCtx
    {
      loco::Node *first_node;                 // starting node of subgraph that will be replaced
      loco::Node *last_node;                  // end node of subgraph that will be replaced
      loco::Node *input_node;                 // input of subgraph
      std::vector<loco::TensorAxis> perm_vec; // perm vector for transpose
 
      TransposeCtx(loco::Node *first, loco::Node *last, loco::Node *input,
                   std::vector<loco::TensorAxis> perm)
        : first_node(first), last_node(last), input_node(input), perm_vec(perm)
      { /* empty */
      }
    };
 
    std::set<std::unique_ptr<TransposeCtx>> transposeCandidates;
  };
 
  Collector collector;
 
  for (auto node : loco::active_nodes(loco::output_nodes(g)))
  {
    if (node->dialect() == loco::CanonicalDialect::get())
    {
      auto canonical_node = loco::must_cast<loco::CanonicalNode *>(node);
      canonical_node->accept(&collector);
    }
  }
 
  for (auto p : collector.forwardCandidates)
  {
    auto forward_node = g->nodes()->create<loco::Forward>();
    forward_node->input(p.second);
    replace(p.first).with(forward_node);
    set_input_null(p.first);
  }
 
  for (auto &ctx : collector.transposeCandidates)
  {
    auto transpose_node = g->nodes()->create<loco::TensorTranspose>();
    {
      transpose_node->perm()->size(ctx->perm_vec.size());
 
      for (loco::TensorAxis axis = 0; axis < ctx->perm_vec.size(); axis++)
        transpose_node->perm()->axis(axis) = ctx->perm_vec[axis];
    }
 
    transpose_node->input(ctx->input_node);
    replace(ctx->last_node).with(transpose_node);
    set_input_null(ctx->first_node);
  }
 
  return (collector.forwardCandidates.size() > 0 or collector.transposeCandidates.size() > 0);
}

References loco::active_nodes(), loco::FeatureDecode::decoder(), loco::Node::dialect(), loco::FeatureEncode::encoder(), loco::CanonicalDialect::get(), loco::Forward::input(), loco::FeatureEncode::input(), loco::FeatureDecode::input(), loco::output_nodes(), loco::TensorTranspose::perm(), loco::replace(), loco::TensorTranspose::Perm::size(), and loco::Subst< SubstQualifier::Default >::with().

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

---

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

• compiler/logo/include/logo/SimplifyDomainConversionPass.h
• compiler/logo/src/Passes/SimplifyDomainConversionPass.cpp