luci::FoldDequantizePass Struct Reference

Class to fold Dequantize, which can be folded by constant inputs. More...

#include <FoldDequantizePass.h>

Collaboration diagram for luci::FoldDequantizePass:

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

Detailed Description

Class to fold Dequantize, which can be folded by constant inputs.

Definition at line 29 of file FoldDequantizePass.h.

Member Function Documentation

name()

const char * luci::FoldDequantizePass::name ( void  ) const

inlinefinalvirtual

Reimplemented from logo::Pass.

Definition at line 31 of file FoldDequantizePass.h.

{ return "luci::FOLD_DEQUANTIZE"; }

run()

bool luci::FoldDequantizePass::run ( loco::Graph *  g )

finalvirtual

Folding pattern 1 - When input of Dequantize is foldable constant

[Before] quantized_const_input -------— Dequantize -------— Op — +– Op1_with_quant_input — +– Op2_with_quant_input —

[After] dequantized_const_input -----------------------------— Op —

quantized_const_input --— Op1_with_quant_input — +– Op2_with_quant_input —

Folding pattern 2 - When input of Dequantize uses quantized output value

[Before] quantized_const_input --— Gather --— Dequantize — Op — +– Op1_with_quant_input — +– Op2_with_quant_input —

[After] dequantized_const_input ---—Gather -----------------— Op —

quantized_const_input --— Op1_with_quant_input — +– Op2_with_quant_input —

Implements logo::Pass.

Definition at line 213 of file FoldDequantizePass.cpp.

{
  bool changed = false;
 
  for (auto node : loco::active_nodes(loco::output_nodes(g)))
  {
    if (auto circle_dequant = dynamic_cast<luci::CircleDequantize *>(node))
    {
      if (auto const_input = dynamic_cast<luci::CircleConst *>(circle_dequant->input()))
      {
        // Pattern 1 - When input of Dequantize is foldable constant
        if (is_foldable_const(const_input))
        {
          loco::replace(circle_dequant).with(dequantized_const_node(const_input));
          changed = true;
        }
      }
    }
    else if (auto const_node = dynamic_cast<luci::CircleConst *>(node))
    {
      if (is_foldable_const(const_node))
      {
        for (auto const_node_user : loco::succs(const_node))
        {
          // If user is hybrid kernel supported operation, do not dequantize
          if (is_hybrid_kernel_supported(const_node_user))
            continue;
 
          auto users = loco::succs(const_node_user);
          if (users.size() > 1)
            continue;
 
          // Pattern 2 - When input of Dequantize uses quantized output value
          if (auto dequant = dynamic_cast<luci::CircleDequantize *>(*users.begin()))
          {
            if (replace_const_node(const_node_user, const_node))
            {
              loco::replace(dequant).with(const_node_user);
              luci::add_origin(loco::must_cast<luci::CircleNode *>(const_node_user),
                               luci::get_origin(dequant));
              changed = true;
            }
          }
        }
      }
    }
  }
 
  return changed;
}

References loco::active_nodes(), loco::output_nodes(), loco::replace(), loco::succs(), and loco::Subst< SubstQualifier::Default >::with().

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

---

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

• compiler/luci/pass/include/luci/Pass/FoldDequantizePass.h
• compiler/luci/pass/src/FoldDequantizePass.cpp