q_implant::QImplant Class Reference

#include <QImplant.h>

Public Member Functions
	QImplant (const std::string &path)
void	write (loco::Graph *g)

Detailed Description

Definition at line 27 of file QImplant.h.

Constructor & Destructor Documentation

QImplant()

q_implant::QImplant::QImplant ( const std::string &  path )

inline

Definition at line 30 of file QImplant.h.

: _path(path) {}

Member Function Documentation

write()

void QImplant::write

(

loco::Graph *

g

)

Definition at line 205 of file QImplant.cpp.

{
  const auto root = load_json(_path);
  const auto dir_path = directory_path(_path);
 
  std::unordered_map<std::string, luci::CircleNode *> name_to_node;
  for (auto node : loco::all_nodes(g))
  {
    auto circle_node = loco::must_cast<luci::CircleNode *>(node);
    if (circle_node->opcode() == luci::CircleOpcode::CIRCLEOUTPUT)
    {
      continue;
    }
 
    name_to_node[circle_node->name()] = circle_node;
  }
 
  THROW_UNLESS(root.isObject());
 
  for (const auto tensor_name : root.getMemberNames())
  {
    const auto tensor = root[tensor_name];
 
    verify_tensor(tensor);
 
    const auto scale_path = dir_path + '/' + tensor["scale"].asString();
    const auto zerop_path = dir_path + '/' + tensor["zerop"].asString();
    const auto quantized_dimension = tensor["quantized_dimension"].asUInt();
    const auto dtype = str_to_dtype(tensor["dtype"].asString());
 
    auto node = name_to_node.at(tensor_name);
 
    // Node must be fp32
    THROW_UNLESS(node->dtype() == loco::DataType::FLOAT32);
 
    node->quantparam(std::make_unique<luci::CircleQuantParam>());
 
    set_dtype(node, dtype);
    set_scale(node, scale_path);
    set_zerop(node, zerop_path);
    set_quantized_dimension(node, quantized_dimension);
 
    if (tensor.isMember("value"))
    {
      auto const_node = loco::must_cast<luci::CircleConst *>(node);
      const auto value_path = dir_path + '/' + tensor["value"].asString();
 
      set_value(const_node, value_path, dtype);
    }
  }
 
  forward_qparam(g);
 
  // Update output nodes
  auto graph_outputs = g->outputs();
  assert(graph_outputs); // FIX_CALLER_UNLESS
  for (auto node : loco::output_nodes(g))
  {
    auto out_node = loco::must_cast<luci::CircleOutput *>(node);
    auto from_node = loco::must_cast<luci::CircleNode *>(out_node->from());
 
    THROW_UNLESS(from_node->quantparam());
 
    out_node->quantparam(std::make_unique<luci::CircleQuantParam>());
    out_node->quantparam()->scale = from_node->quantparam()->scale;
    out_node->quantparam()->zerop = from_node->quantparam()->zerop;
    out_node->quantparam()->quantized_dimension = from_node->quantparam()->quantized_dimension;
    out_node->dtype(from_node->dtype());
 
    auto graph_output = graph_outputs->at(out_node->index());
    graph_output->dtype(out_node->dtype());
  }
 
  // Verify quantized model
  for (auto node : loco::active_nodes(loco::output_nodes(g)))
  {
    auto circle_node = loco::must_cast<luci::CircleNode *>(node);
 
    // Throw an exception if dtype is not float32
    // TODO Operator-level verification (ex: using QuantizedModelVerifier)
    THROW_UNLESS(circle_node->dtype() != loco::DataType::FLOAT32);
  }
}

References loco::active_nodes(), loco::all_nodes(), loco::output_nodes(), and THROW_UNLESS.

Referenced by entry().

---

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

• compiler/q-implant/include/QImplant.h
• compiler/q-implant/src/QImplant.cpp