minmax_embedder::Embedder Class Reference

#include <Embedder.h>

Public Member Functions
void	embed (const std::string &output_path, const std::string &input_path, const std::string &minmax_path, const EmbedderOptions &)

Detailed Description

Definition at line 31 of file Embedder.h.

Member Function Documentation

embed()

void minmax_embedder::Embedder::embed	(	const std::string &	output_path,
		const std::string &	input_path,
		const std::string &	minmax_path,
		const EmbedderOptions &	opt
	)

Definition at line 77 of file Embedder.cpp.

{
  // Load model from the file
  luci::ImporterEx importerex;
  auto module = importerex.importVerifyModule(input_path);
  if (module.get() == nullptr)
    throw std::runtime_error{"Input circle is invalid"};
 
  h5::Reader mmr{minmax_path};
 
  for (size_t idx = 0; idx < module->size(); ++idx)
  {
    auto graph = module->graph(idx);
 
    /* read subgraph inputs */
    const auto input_nodes = loco::input_nodes(graph);
    const auto n_inputs = input_nodes.size();
    for (size_t input_idx = 0; input_idx < n_inputs; ++input_idx)
    {
      const auto *circle_input = loco::must_cast<const luci::CircleInput *>(input_nodes[input_idx]);
      if (circle_input->index() != input_idx)
        throw std::runtime_error("Input order in minmax recording does not match to circle");
 
      auto minmax = mmr.read_input(0, idx, input_idx);
      auto min = getNthPercentile(minmax.min_vector, opt.min_percentile);
      auto max = getNthPercentile(minmax.max_vector, opt.max_percentile);
      auto quantparam = std::make_unique<luci::CircleQuantParam>();
      quantparam->min.push_back(min);
      quantparam->max.push_back(max);
      const auto *circle_node = loco::must_cast<const luci::CircleNode *>(input_nodes[input_idx]);
      auto mutable_node = const_cast<luci::CircleNode *>(circle_node);
      mutable_node->quantparam(std::move(quantparam));
    }
 
    /* read op outputs */
    uint32_t n_nodes = graph->nodes()->size();
    for (uint32_t i = 0; i < n_nodes; ++i)
    {
      auto node = loco::must_cast<luci::CircleNode *>(graph->nodes()->at(i));
      if (not luci::has_node_id(node)) // Skip non-op nodes (e.g. input/const/output)
        continue;
      auto op_idx = luci::get_node_id(node);
      auto minmax = mmr.read(0, idx, op_idx);
      auto min = getNthPercentile(minmax.min_vector, opt.min_percentile);
      auto max = getNthPercentile(minmax.max_vector, opt.max_percentile);
      auto quantparam = std::make_unique<luci::CircleQuantParam>();
      quantparam->min.push_back(min);
      quantparam->max.push_back(max);
      auto mutable_node = const_cast<luci::CircleNode *>(node);
      mutable_node->quantparam(std::move(quantparam));
    }
 
    if (!luci::validate(graph))
      throw std::runtime_error{"Circle after embedding minmax is invalid"};
  }
 
  // Export to output Circle file
  luci::CircleExporter exporter;
 
  luci::CircleFileExpContract contract(module.get(), output_path);
 
  if (!exporter.invoke(&contract))
    throw std::runtime_error{"Failed to export circle"};
}

References luci::get_node_id(), luci::has_node_id(), loco::input_nodes(), luci::CircleExporter::invoke(), minmax_embedder::EmbedderOptions::max_percentile, minmax_embedder::EmbedderOptions::min_percentile, luci::CircleNode::quantparam(), and luci::validate().

Referenced by entry().

---

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

• compiler/minmax-embedder/include/minmax-embedder/Embedder.h
• compiler/minmax-embedder/src/Embedder.cpp