dalgona Namespace Reference

Data Structures
class	Dalgona
class	PostOperatorHook
class	PreOperatorHook
class	PythonHooks

Functions
std::vector< float >	genRandomFloatData (uint32_t num_elements, float min, float max)
template<typename T >
std::vector< T >	genRandomIntData (uint32_t num_elements, T min, T max)
const std::string	toString (luci::CircleOpcode opcode)
const std::string	toString (luci::FusedActFunc fused_act)
py::object	none ()
std::vector< py::dict >	inputsPyArray (const luci::CircleNode *node, luci_interpreter::Interpreter *interpreter)
std::vector< py::dict >	outputsPyArray (const luci::CircleNode *node, luci_interpreter::Interpreter *interpreter)
py::dict	outputPyArray (const luci::CircleNode *node, luci_interpreter::Interpreter *interpreter)
bool	multi_out_node (const luci::CircleNode *node)
template<typename... Args>
void	pySafeCall (py::object func, Args... args)

Function Documentation

genRandomFloatData()

std::vector< float > dalgona::genRandomFloatData	(	uint32_t	num_elements,
		float	min,
		float	max
	)

Definition at line 26 of file RandomUtils.cpp.

{
  if (min > max)
    throw std::invalid_argument("min is greater than max");
 
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_real_distribution<> dist(min, max);
  std::vector<float> buffer(num_elements);
 
  // Write random data
  for (auto &iter : buffer)
    iter = static_cast<float>(dist(gen));
 
  return buffer;
}

Referenced by dalgona::Dalgona::runAnalysisWithRandomInput().

genRandomIntData()

template<typename T >

std::vector< T > dalgona::genRandomIntData	(	uint32_t	num_elements,
		T	min,
		T	max
	)

Definition at line 28 of file RandomUtils.h.

{
  if (min > max)
    throw std::invalid_argument("min is greater than max");
 
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution<T> dist(min, max);
  std::vector<T> buffer(num_elements);
 
  // Write random data
  for (auto &iter : buffer)
    iter = dist(gen);
 
  return buffer;
}

inputsPyArray()

std::vector< py::dict > dalgona::inputsPyArray	(	const luci::CircleNode *	node,
		luci_interpreter::Interpreter *	interpreter
	)

Definition at line 109 of file Utils.cpp.

{
  assert(node != nullptr);        // FIX_CALLER_UNLESS
  assert(interpreter != nullptr); // FIX_CALLER_UNLESS
 
  std::vector<py::dict> inputs;
  for (uint32_t i = 0; i < node->arity(); ++i)
  {
    const auto input_tensor = interpreter->getTensor(node->arg(i));
    auto circle_node = static_cast<luci::CircleNode *>(node->arg(i));
 
    // skip invalid inputs (e.g., non-existing bias in TCONV)
    if (circle_node->opcode() == luci::CircleOpcode::CIRCLEOUTPUTEXCLUDE)
      continue;
 
    auto py_input =
      py::dict("name"_a = circle_node->name(), "data"_a = numpyArray(input_tensor),
               "quantparam"_a = quantparam(input_tensor),
               "is_const"_a = circle_node->opcode() == luci::CircleOpcode::CIRCLECONST);
    inputs.push_back(py_input);
  }
  return inputs;
}

References loco::Node::arg(), and loco::Node::arity().

Referenced by dalgona::PostOperatorHook::visit(), and dalgona::PreOperatorHook::visit().

multi_out_node()

bool dalgona::multi_out_node

(

const luci::CircleNode *

node

)

Definition at line 175 of file Utils.cpp.

{
  switch (node->opcode())
  {
    // TODO Update this list when new Op is added
    // Tip: grep "public GraphBuilderMultiOutput" in luci/import
    case luci::CircleOpcode::BIDIRECTIONAL_SEQUENCE_LSTM:
    case luci::CircleOpcode::CUSTOM:
    case luci::CircleOpcode::IF:
    case luci::CircleOpcode::NON_MAX_SUPPRESSION_V4:
    case luci::CircleOpcode::NON_MAX_SUPPRESSION_V5:
    case luci::CircleOpcode::SPLIT:
    case luci::CircleOpcode::SPLIT_V:
    case luci::CircleOpcode::TOPK_V2:
    case luci::CircleOpcode::UNIQUE:
    case luci::CircleOpcode::UNPACK:
      return true;
    default:
      return false;
  }
}

References luci::CircleNode::opcode().

Referenced by dalgona::PostOperatorHook::visit().

none()

py::object dalgona::none

(

)

Definition at line 107 of file Utils.cpp.

{ return py::none(); }

Referenced by dalgona::PostOperatorHook::visit(), and dalgona::PreOperatorHook::visit().

outputPyArray()

py::dict dalgona::outputPyArray	(	const luci::CircleNode *	node,
		luci_interpreter::Interpreter *	interpreter
	)

Definition at line 160 of file Utils.cpp.

{
  assert(node != nullptr);        // FIX_CALLER_UNLESS
  assert(interpreter != nullptr); // FIX_CALLER_UNLESS
 
  const auto tensor = interpreter->getTensor(node);
 
  THROW_UNLESS(tensor != nullptr, "Null tensor detected in " + node->name());
 
  auto py_output = py::dict("name"_a = node->name(), "data"_a = numpyArray(tensor),
                            "quantparam"_a = quantparam(tensor),
                            "is_const"_a = node->opcode() == luci::CircleOpcode::CIRCLECONST);
  return py_output;
}

References luci::CircleNode::name(), luci::CircleNode::opcode(), and THROW_UNLESS.

Referenced by dalgona::PythonHooks::endNetworkExecution(), dalgona::PythonHooks::startNetworkExecution(), and dalgona::PostOperatorHook::visit().

outputsPyArray()

std::vector< py::dict > dalgona::outputsPyArray	(	const luci::CircleNode *	node,
		luci_interpreter::Interpreter *	interpreter
	)

Definition at line 134 of file Utils.cpp.

{
  std::vector<py::dict> outputs;
  for (auto succ : loco::succs(node))
  {
    const auto output_tensor = interpreter->getTensor(succ);
    auto circle_node = static_cast<luci::CircleNode *>(succ);
 
    auto opcode_str = toString(circle_node->opcode());
    // Check if node is a multi-output node
    // Assumption: Multi-output virtual nodes have 'Out' prefix
    // TODO Fix this if the assumption changes
    THROW_UNLESS(opcode_str.substr(opcode_str.length() - 3) == "Out",
                 "Invalid output detected in " + node->name());
 
    auto py_output =
      py::dict("name"_a = circle_node->name(), "data"_a = numpyArray(output_tensor),
               "quantparam"_a = quantparam(output_tensor),
               "is_const"_a = circle_node->opcode() == luci::CircleOpcode::CIRCLECONST);
    outputs.push_back(py_output);
  }
  return outputs;
}

References luci::CircleNode::name(), loco::succs(), THROW_UNLESS, and toString().

Referenced by dalgona::PostOperatorHook::visit().

pySafeCall()

template<typename... Args>

void dalgona::pySafeCall	(	py::object	func,
		Args...	args
	)

Definition at line 29 of file Utils.h.

{
  try
  {
    func(args...);
  }
  catch (py::error_already_set &e)
  {
    throw std::runtime_error(e.what());
  }
}

Referenced by dalgona::PythonHooks::endAnalysis(), dalgona::PythonHooks::endNetworkExecution(), dalgona::PythonHooks::importAnalysis(), dalgona::PythonHooks::startNetworkExecution(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), and dalgona::PreOperatorHook::visit().

toString() [1/2]

const std::string dalgona::toString

(

luci::CircleOpcode

opcode

)

Definition at line 26 of file StringUtils.cpp.

{
  static const char *names[] = {
#define CIRCLE_NODE(OPCODE, CIRCLE_CLASS) #CIRCLE_CLASS,
#define CIRCLE_VNODE(OPCODE, CIRCLE_CLASS) #CIRCLE_CLASS,
#include <luci/IR/CircleNodes.lst>
#undef CIRCLE_NODE
#undef CIRCLE_VNODE
  };
 
  auto const node_name = names[static_cast<int>(opcode)];
 
  assert(std::string(node_name).substr(0, 6) == "Circle"); // FIX_ME_UNLESS
 
  // Return substring of class name ("Circle" is sliced out)
  // Ex: Return "Conv2D" for "CircleConv2D" node
  return std::string(node_name).substr(6);
}

Referenced by outputsPyArray(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), dalgona::PreOperatorHook::visit(), dalgona::PostOperatorHook::visit(), and dalgona::PreOperatorHook::visit().

toString() [2/2]

const std::string dalgona::toString

(

luci::FusedActFunc

fused_act

)

Definition at line 45 of file StringUtils.cpp.

{
  switch (fused_act)
  {
    case (luci::FusedActFunc::UNDEFINED):
      return std::string("undefined");
    case (luci::FusedActFunc::NONE):
      return std::string("none");
    case (luci::FusedActFunc::RELU):
      return std::string("relu");
    case (luci::FusedActFunc::RELU_N1_TO_1):
      return std::string("relu_n1_to_1");
    case (luci::FusedActFunc::RELU6):
      return std::string("relu6");
    case (luci::FusedActFunc::TANH):
      return std::string("tanh");
    case (luci::FusedActFunc::SIGN_BIT):
      return std::string("sign_bit");
    default:
      throw std::runtime_error("Unsupported activation function");
  }
}

References luci::NONE, luci::RELU, luci::RELU6, luci::RELU_N1_TO_1, luci::SIGN_BIT, luci::TANH, and luci::UNDEFINED.