luci::QuantizedModelVerifier Struct Reference

Class to verify quantized model. More...

#include <QuantizedModelVerifier.h>

Data Structures
struct	Context

Public Member Functions
	QuantizedModelVerifier (std::unique_ptr< Context > &&ctx)
void	verify (loco::Graph *g)

Detailed Description

Class to verify quantized model.

TODO Move this to luci/service

Definition at line 34 of file QuantizedModelVerifier.h.

Constructor & Destructor Documentation

QuantizedModelVerifier()

luci::QuantizedModelVerifier::QuantizedModelVerifier ( std::unique_ptr< Context > &&  ctx )

inline

Definition at line 48 of file QuantizedModelVerifier.h.

                                                       : _ctx{std::move(ctx)}
  {
    // DO NOTHING
  }

Member Function Documentation

verify()

void luci::QuantizedModelVerifier::verify

(

loco::Graph *

g

)

Definition at line 29 of file QuantizedModelVerifier.cpp.

{
  if (_ctx->granularity != Granularity::ChannelWise && _ctx->granularity != Granularity::LayerWise)
    throw std::runtime_error("Unsupported granularity");
 
  auto info_by_name = layer_info_map(g, _ctx->layers_info);
 
  auto quantize_dtype = [&](const luci::CircleNode *node) {
    auto iter = info_by_name.find(node->name());
 
    // Return designated quantization dtype
    if (iter != info_by_name.end())
      return iter->second.dtype;
 
    // Return default quantization dtype
    return _ctx->output_model_dtype;
  };
 
  auto quantize_granularity = [&](const luci::CircleNode *node) {
    auto iter = info_by_name.find(node->name());
 
    // Return designated quantization granularity
    if (iter != info_by_name.end())
      return iter->second.granularity;
 
    // Return default quantization granularity
    return _ctx->granularity;
  };
 
  for (auto node : loco::active_nodes(loco::output_nodes(g)))
  {
    auto circle_node = loco::must_cast<luci::CircleNode *>(node);
 
    auto node_name = [&circle_node]() {
      if (circle_node->name().length() == 0)
        return std::string("(noname)");
 
      return circle_node->name();
    };
 
    // Verify Type
    if (!VerifyQuantizedNodeType::create(quantize_dtype(circle_node))->verify(circle_node))
      throw std::runtime_error("Wrong data type detected in " + node_name());
 
    // Verify Granularity
    if (!circle_node->accept(
          VerifyQuantizedNodeGranularity::create(quantize_granularity(circle_node)).get()))
      throw std::runtime_error("Wrong granularity detected in " + node_name());
 
    // Verify Bias scale
    if (!VerifyQuantizedBiasScale::create()->verify(circle_node))
      throw std::runtime_error("Wrong bias scale detected in " + node_name());
  }
}

References loco::active_nodes(), luci::VerifyQuantizedBiasScale::create(), luci::VerifyQuantizedNodeGranularity::create(), luci::VerifyQuantizedNodeType::create(), luci::layer_info_map(), and loco::output_nodes().

---

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

• compiler/luci/pass/src/QuantizedModelVerifier.h
• compiler/luci/pass/src/QuantizedModelVerifier.cpp