onert::backend::cpu::ops::QuantizeLayer Class Reference

#include <QuantizeLayer.h>

Collaboration diagram for onert::backend::cpu::ops::QuantizeLayer:

Public Member Functions
	QuantizeLayer ()
void	configure (const IPortableTensor *input, IPortableTensor *output)
void	run () override
Public Member Functions inherited from onert::exec::IFunction
virtual	~IFunction ()=default
virtual void	prepare ()

Detailed Description

Definition at line 26 of file QuantizeLayer.h.

Constructor & Destructor Documentation

QuantizeLayer()

onert::backend::cpu::ops::QuantizeLayer::QuantizeLayer ( )

inline

Definition at line 29 of file QuantizeLayer.h.

                  : _input(nullptr), _output(nullptr), _output_multiplier(0), _output_shift(0)
  {
    // DO NOTHING
  }

Member Function Documentation

configure()

void onert::backend::cpu::ops::QuantizeLayer::configure	(	const IPortableTensor *	input,
		IPortableTensor *	output
	)

Definition at line 36 of file QuantizeLayer.cc.

{
  assert(input != nullptr);
  assert(output != nullptr);
 
  _input = input;
  _output = output;
 
  if ((_input->data_type() == OperandType::FLOAT32))
  {
    // DO NOTHING
  }
  else if (((input->data_type() == OperandType::QUANT_UINT8_ASYMM) &&
            (output->data_type() == OperandType::QUANT_INT8_ASYMM)) ||
           ((input->data_type() == OperandType::QUANT_INT8_ASYMM) &&
            (output->data_type() == OperandType::QUANT_UINT8_ASYMM)))
  {
    const double effective_output_scale =
      static_cast<double>(input->data_scale()) / static_cast<double>(output->data_scale());
    QuantizeMultiplier(effective_output_scale, &_output_multiplier, &_output_shift);
  }
  else
  {
    throw std::runtime_error{"Quantize: Unsupported  data type"};
  }
}

References onert::backend::IPortableTensor::data_type(), and onert::backend::cpu::ops::QuantizeMultiplier().

run()

void onert::backend::cpu::ops::QuantizeLayer::run ( )

overridevirtual

Implements onert::exec::IFunction.

Definition at line 63 of file QuantizeLayer.cc.

{
  if ((_input->data_type() == OperandType::FLOAT32))
  {
    affineQuantize<float, uint8_t>(_input, _output);
  }
  else if ((_input->data_type() == OperandType::QUANT_UINT8_ASYMM) &&
           (_output->data_type() == OperandType::QUANT_INT8_ASYMM))
  {
    nnfw::cker::Requantize<uint8_t, int8_t>(
      getBuffer<uint8_t>(_input), MatchingFlatSize(getShape(_input), getShape(_output)),
      _output_multiplier, _output_shift, _input->data_zero_point(), _output->data_zero_point(),
      getBuffer<int8_t>(_output));
  }
  else if ((_input->data_type() == OperandType::QUANT_INT8_ASYMM) &&
           (_output->data_type() == OperandType::QUANT_UINT8_ASYMM))
  {
    nnfw::cker::Requantize<int8_t, uint8_t>(
      getBuffer<int8_t>(_input), MatchingFlatSize(getShape(_input), getShape(_output)),
      _output_multiplier, _output_shift, _input->data_zero_point(), _output->data_zero_point(),
      getBuffer<uint8_t>(_output));
  }
  else
  {
    throw std::runtime_error{"Quantize: Unsupported  data type"};
  }
}

References onert::backend::IPortableTensor::data_type(), onert::backend::IPortableTensor::data_zero_point(), onert::backend::cpu::ops::getShape(), MatchingFlatSize(), nnfw::cker::Requantize< int8_t, uint8_t >(), and nnfw::cker::Requantize< uint8_t, int8_t >().

---

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

• runtime/onert/backend/cpu/ops/QuantizeLayer.h
• runtime/onert/backend/cpu/ops/QuantizeLayer.cc