dalgona::PostOperatorHook Class Reference

#include <PostOperatorHook.h>

Collaboration diagram for dalgona::PostOperatorHook:

Public Member Functions
	PostOperatorHook (py::object analysis, luci_interpreter::Interpreter *interpreter)
void	visit (const luci::CircleNode *node)
	Default fallback.
void	visit (const luci::CircleConv2D *node)
void	visit (const luci::CircleDepthwiseConv2D *node)
void	visit (const luci::CircleAdd *node)
void	visit (const luci::CircleFullyConnected *node)
void	visit (const luci::CircleTransposeConv *node)
void	visit (const luci::CircleInstanceNorm *node)
void	visit (const luci::CircleSplit *node)
Public Member Functions inherited from luci::CircleNodeVisitor< void >
virtual	~CircleNodeVisitor ()=default
Public Member Functions inherited from luci::CircleNodeVisitorBase< T >
virtual	~CircleNodeVisitorBase ()=default

Detailed Description

Definition at line 37 of file PostOperatorHook.h.

Constructor & Destructor Documentation

PostOperatorHook()

dalgona::PostOperatorHook::PostOperatorHook ( py::object  analysis, luci_interpreter::Interpreter *  interpreter  )

inlineexplicit

Definition at line 72 of file PostOperatorHook.h.

    : _analysis(analysis), _interpreter(interpreter)
  {
    // Do nothing
  }

Member Function Documentation

visit() [1/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleAdd *  node )

inline

Definition at line 170 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE(Add)
 
    auto fused_act = node->fusedActivationFunction();
 
    pySafeCall(hook,
               node->name(),       // name
               inputs[0],          // x
               inputs[1],          // y
               output,             // output
               toString(fused_act) // fused activation
    );
  }

References Add(), luci::CircleNodeMixin< CircleNodeTrait::FusedActFunc >::fusedActivationFunction(), luci::CircleNode::name(), POST_OPERATOR_HOOK_PROLOGUE, dalgona::pySafeCall(), and dalgona::toString().

visit() [2/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleConv2D *  node )

inline

Definition at line 116 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE(Conv2D)
 
    auto padding = node->padding();
    auto stride = node->stride();
    auto dilation = node->dilation();
 
    auto py_stride = py::dict("w"_a = stride->w(), "h"_a = stride->h());
    auto py_dilation = py::dict("w"_a = dilation->w(), "h"_a = dilation->h());
 
    auto fused_act = node->fusedActivationFunction();
 
    pySafeCall(hook,
               node->name(),                                      // name
               inputs[0],                                         // input
               inputs[1],                                         // filter
               inputs[2],                                         // bias
               padding == luci::Padding::SAME ? "SAME" : "VALID", // padding
               py_stride,                                         // stride
               py_dilation,                                       // dilation
               output,                                            // output
               toString(fused_act)                                // fused activation
    );
  }

References luci::CircleConv2D::dilation(), luci::CircleNodeMixin< CircleNodeTrait::FusedActFunc >::fusedActivationFunction(), luci::CircleNode::name(), luci::CircleConv2D::padding(), POST_OPERATOR_HOOK_PROLOGUE, dalgona::pySafeCall(), luci::SAME, luci::CircleConv2D::stride(), and dalgona::toString().

visit() [3/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleDepthwiseConv2D *  node )

inline

Definition at line 142 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE(DepthwiseConv2D)
 
    auto padding = node->padding();
    auto stride = node->stride();
    auto dilation = node->dilation();
    auto depthMultiplier = node->depthMultiplier();
 
    auto py_stride = py::dict("w"_a = stride->w(), "h"_a = stride->h());
    auto py_dilation = py::dict("w"_a = dilation->w(), "h"_a = dilation->h());
 
    auto fused_act = node->fusedActivationFunction();
 
    pySafeCall(hook,
               node->name(),                                      // name
               inputs[0],                                         // input
               inputs[1],                                         // filter
               inputs[2],                                         // bias
               padding == luci::Padding::SAME ? "SAME" : "VALID", // padding
               py_stride,                                         // stride
               depthMultiplier,                                   // depthMultiplier
               py_dilation,                                       // dilation
               output,                                            // output
               toString(fused_act)                                // fused activation
    );
  }

References luci::CircleDepthwiseConv2D::depthMultiplier(), DepthwiseConv2D, luci::CircleDepthwiseConv2D::dilation(), luci::CircleNodeMixin< CircleNodeTrait::FusedActFunc >::fusedActivationFunction(), luci::CircleNode::name(), luci::CircleDepthwiseConv2D::padding(), POST_OPERATOR_HOOK_PROLOGUE, dalgona::pySafeCall(), luci::SAME, luci::CircleDepthwiseConv2D::stride(), and dalgona::toString().

visit() [4/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleFullyConnected *  node )

inline

Definition at line 185 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE(FullyConnected)
 
    auto fused_act = node->fusedActivationFunction();
    py::dict bias;
    // bias is optional
    if (inputs.size() == 3)
    {
      bias = inputs[2];
    }
    pySafeCall(hook,
               node->name(),       // name
               inputs[0],          // input
               inputs[1],          // weights
               bias,               // bias
               output,             // output
               toString(fused_act) // fused activation
    );
  }

References FullyConnected(), luci::CircleNodeMixin< CircleNodeTrait::FusedActFunc >::fusedActivationFunction(), luci::CircleNode::name(), POST_OPERATOR_HOOK_PROLOGUE, dalgona::pySafeCall(), and dalgona::toString().

visit() [5/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleInstanceNorm *  node )

inline

Definition at line 227 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE(InstanceNorm)
 
    auto epsilon = node->epsilon();
 
    auto fused_act = node->fusedActivationFunction();
 
    pySafeCall(hook,
               node->name(),       // name
               inputs[0],          // input
               inputs[1],          // gamma
               inputs[2],          // beta
               epsilon,            // epsilon
               output,             // output
               toString(fused_act) // fused activation
    );
  }

References luci::CircleInstanceNorm::epsilon(), luci::CircleNodeMixin< CircleNodeTrait::FusedActFunc >::fusedActivationFunction(), POST_OPERATOR_HOOK_PROLOGUE, dalgona::pySafeCall(), and dalgona::toString().

visit() [6/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleNode *  )

inlinevirtual

Default fallback.

Reimplemented from luci::CircleNodeVisitor< void >.

Definition at line 79 of file PostOperatorHook.h.

  {
    if (not py::hasattr(_analysis, "DefaultOpPost"))
      return;
 
    py::object hook = _analysis.attr("DefaultOpPost");
    auto inputs = inputsPyArray(node, _interpreter);
 
    py::list input_list;
    for (uint32_t i = 0; i < inputs.size(); i++)
    {
      input_list.append(inputs[i]);
    }
 
    py::list output_list;
    if (multi_out_node(node))
    {
      auto outputs = outputsPyArray(node, _interpreter);
      for (uint32_t i = 0; i < outputs.size(); i++)
      {
        output_list.append(outputs[i]);
      }
    }
    else
    {
      auto output = outputPyArray(node, _interpreter);
      output_list.append(output);
    }
 
    pySafeCall(hook,
               node->name(),             // name
               toString(node->opcode()), // opcode
               input_list,               // list of inputs
               output_list               // list of outputs
    );
  }

References dalgona::inputsPyArray(), dalgona::multi_out_node(), luci::CircleNode::name(), luci::CircleNode::opcode(), dalgona::outputPyArray(), dalgona::outputsPyArray(), dalgona::pySafeCall(), and dalgona::toString().

visit() [7/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleSplit *  node )

inline

Definition at line 246 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE_MULTI_OUTS(Split)
 
    py::list output_list;
    for (uint32_t i = 0; i < outputs.size(); i++)
    {
      output_list.append(outputs[i]);
    }
 
    auto num_split = node->num_split();
 
    pySafeCall(hook,
               node->name(), // name
               inputs[0],    // split_dim
               inputs[1],    // input
               num_split,    // num_split
               output_list   // list of outputs
    );
  }

References luci::CircleNode::name(), luci::CircleSplit::num_split(), POST_OPERATOR_HOOK_PROLOGUE_MULTI_OUTS, and dalgona::pySafeCall().

visit() [8/8]

void dalgona::PostOperatorHook::visit ( const luci::CircleTransposeConv *  node )

inline

Definition at line 206 of file PostOperatorHook.h.

  {
    POST_OPERATOR_HOOK_PROLOGUE(TransposeConv)
 
    auto padding = node->padding();
    auto stride = node->stride();
 
    auto py_stride = py::dict("w"_a = stride->w(), "h"_a = stride->h());
 
    pySafeCall(hook,
               node->name(),                                      // name
               inputs[2],                                         // input
               inputs[1],                                         // filter
               inputs[0],                                         // output shape
               inputs.size() == 4 ? inputs[3] : none(),           // bias
               padding == luci::Padding::SAME ? "SAME" : "VALID", // padding
               py_stride,                                         // stride
               output                                             // output
    );
  }

References luci::CircleNode::name(), dalgona::none(), luci::CircleTransposeConv::padding(), POST_OPERATOR_HOOK_PROLOGUE, dalgona::pySafeCall(), luci::SAME, and luci::CircleTransposeConv::stride().

---

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

• compiler/dalgona/src/PostOperatorHook.h