#include <Quantizer.h>

Data Structures
struct	Context

Public Member Functions
	Quantizer (const Context &ctx)

void	setHook (const QuantizerHook *callback)
	set hook on the end of quantization event

bool	quantize (luci::Module *module, const std::string &quant_dtype, LayerParams &layer_params)
	quantize recorded module (min/max initialized) with specified parameters returns true on success

bool	quantize (luci::Module *module, LayerParams &layer_params)
	quantize recorded module (min/max initialized) with specified parameters returns true on success

bool	fakeQuantize (luci::Module *module, const std::string &quant_dtype, LayerParams &layer_params)
	fake_quantize recorded module (min/max initialized) with specified parameters returns true on success

const Context &	getContext () const

Detailed Description

Definition at line 44 of file Quantizer.h.

Constructor & Destructor Documentation

◆ Quantizer()

mpqsolver::core::Quantizer::Quantizer ( const Context & ctx )

inline

Definition at line 59 of file Quantizer.h.

59: _ctx(ctx) {}

Member Function Documentation

◆ fakeQuantize()

bool Quantizer::fakeQuantize	(	luci::Module *	module,
		const std::string &	quant_dtype,
		LayerParams &	layer_params
	)

fake_quantize recorded module (min/max initialized) with specified parameters returns true on success

Definition at line 132 of file Quantizer.cpp.

{
  if (!quantize(module, quant_dtype, layer_params))
    return false;
 
  if (!make_model_fake_quantized(module))
    return false;
 
  return true;
}

References quantize().

◆ getContext()

const Context & mpqsolver::core::Quantizer::getContext ( ) const

inline

Definition at line 85 of file Quantizer.h.

85{ return _ctx; }

◆ quantize() [1/2]

bool Quantizer::quantize	(	luci::Module *	module,
		const std::string &	quant_dtype,
		LayerParams &	layer_params
	)

quantize recorded module (min/max initialized) with specified parameters returns true on success

Definition at line 58 of file Quantizer.cpp.

{
  if (!module)
    return false;
 
  static const std::string default_dtype = "float32";
 
  luci::CircleQuantizer quantizer;
 
  auto options = quantizer.options();
  options->enable(Algorithms::QuantizeWithMinMax);
 
  options->param(AlgorithmParameters::Quantize_input_model_dtype, default_dtype);
  options->param(AlgorithmParameters::Quantize_output_model_dtype, quant_dtype);
  // Only channel-wise quantization is supported for int16
  // TODO Fix this if this assumption breaks
  if (quant_dtype == "int16")
    options->param(AlgorithmParameters::Quantize_granularity, "channel");
  else
    options->param(AlgorithmParameters::Quantize_granularity, _ctx.granularity);
 
  options->param(AlgorithmParameters::Quantize_input_type, _ctx.input_type);
  options->param(AlgorithmParameters::Quantize_output_type, _ctx.output_type);
  options->param(AlgorithmParameters::Quantize_TF_style_maxpool,
                 _ctx.TF_style_maxpool ? "True" : "False");
  options->param(AlgorithmParameters::Quantize_save_min_max, _ctx.save_min_max ? "True" : "False");
 
  if (!layer_params.empty())
  {
    try
    {
      options->layer_params(AlgorithmParameters::Quantize_layer_params, layer_params);
    }
    catch (const std::runtime_error &e)
    {
      std::cerr << e.what() << '\n';
      return false;
    }
  }
 
  for (size_t idx = 0; idx < module->size(); ++idx)
  {
    auto graph = module->graph(idx);
    // quantize the graph
    quantizer.quantize(graph);
    if (!luci::validate(graph))
    {
      std::cerr << "ERROR: Quantized graph is invalid" << std::endl;
      return false;
    }
  }
 
  if (_hook)
  {
    _hook->onQuantized(module);
  }
 
  return true;
}

References mpqsolver::core::Quantizer::Context::granularity, mpqsolver::core::Quantizer::Context::input_type, mpqsolver::core::QuantizerHook::onQuantized(), luci::CircleQuantizer::options(), mpqsolver::core::Quantizer::Context::output_type, luci::CircleQuantizer::quantize(), mpqsolver::core::Quantizer::Context::save_min_max, mpqsolver::core::Quantizer::Context::TF_style_maxpool, and luci::validate().

Referenced by fakeQuantize(), and quantize().

◆ quantize() [2/2]

bool Quantizer::quantize	(	luci::Module *	module,
		LayerParams &	layer_params
	)

quantize recorded module (min/max initialized) with specified parameters returns true on success

Definition at line 123 of file Quantizer.cpp.

{
  return quantize(module, _ctx.output_model_dtype, layer_params);
}

References mpqsolver::core::Quantizer::Context::output_model_dtype, and quantize().

◆ setHook()

void Quantizer::setHook ( const QuantizerHook * callback )

set hook on the end of quantization event

Definition at line 52 of file Quantizer.cpp.

52{ _hook = hook; }

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

compiler/circle-mpqsolver/src/core/Quantizer.h
compiler/circle-mpqsolver/src/core/Quantizer.cpp

Data Structures

Public Member Functions