#include <MinMaxObserver.h>

Collaboration diagram for record_minmax::MinMaxObserver:

Public Member Functions
	MinMaxObserver ()

void	postTensorWrite (const luci::CircleNode node, const luci_interpreter::Tensor tensor) override

const MinMaxMap *	minMaxData ()

Public Member Functions inherited from luci_interpreter::ExecutionObserver
virtual	~ExecutionObserver ()

virtual void	preOperatorExecute (const luci::CircleNode *node)

virtual void	postOperatorExecute (const luci::CircleNode *node)

Detailed Description

Definition at line 60 of file MinMaxObserver.h.

Constructor & Destructor Documentation

◆ MinMaxObserver()

record_minmax::MinMaxObserver::MinMaxObserver ( )

inline

Definition at line 63 of file MinMaxObserver.h.

  {
    // Do nothing
  }

Member Function Documentation

◆ minMaxData()

const MinMaxMap * record_minmax::MinMaxObserver::minMaxData ( )

inline

Definition at line 72 of file MinMaxObserver.h.

72{ return &_minmax_data; }

◆ postTensorWrite()

void record_minmax::MinMaxObserver::postTensorWrite	(	const luci::CircleNode *	node,
		const luci_interpreter::Tensor *	tensor
	)

overridevirtual

Reimplemented from luci_interpreter::ExecutionObserver.

Definition at line 30 of file MinMaxObserver.cpp.

{
  // CircleOutput does not produce a tensor
  assert(node->opcode() != luci::CircleOpcode::CIRCLEOUTPUT);
 
  // Operators with multiple outputs
  assert(node->opcode() != luci::CircleOpcode::IF);
  assert(node->opcode() != luci::CircleOpcode::SPLIT);
  assert(node->opcode() != luci::CircleOpcode::SPLIT_V);
  assert(node->opcode() != luci::CircleOpcode::TOPK_V2);
  assert(node->opcode() != luci::CircleOpcode::UNPACK);
  assert(node->opcode() != luci::CircleOpcode::WHILE);
 
  if (node->opcode() == luci::CircleOpcode::CIRCLECONST)
  {
    // node is not activation. Do nothing.
    return;
  }
 
  if (node->dtype() == DataType::BOOL)
  {
    // Bool type tensor is not quantized
    return;
  }
  if (node->dtype() == DataType::S32)
  {
    // Integer type tensor is not quantized
    return;
  }
  if (node->dtype() == DataType::S64)
  {
    // Integer type tensor is not quantized
    return;
  }
 
  // Only support recording of float32 values
  if (tensor->element_type() != DataType::FLOAT32)
  {
    // Exceptions that should be processed in backends
    switch (node->opcode())
    {
      case luci::CircleOpcode::CAST:
        // Cast is quantized only if it converts <type> -> float.
        // Other cases should be processed in backends.
      case luci::CircleOpcode::RESHAPE:
        // Reshape changes only shape of input tensor, efficiently is it a no-op.
        return;
      default:
        throw std::runtime_error("Tensor's data type is not float. " + node->name());
    }
  }
 
  const auto data = tensor->data<float>();
  const auto num_elements = tensor->shape().num_elements();
 
  std::vector<float> buf(data, data + num_elements);
 
  float max = std::numeric_limits<float>::lowest();
  float min = std::numeric_limits<float>::max();
 
  bool all_nan = true;
  for (auto number : buf)
  {
    if (isnan(number))
      continue;
 
    // TODO use metadata hints to detect such cases
    if (number == std::numeric_limits<float>::lowest())
      continue;
 
    all_nan = false;
 
    if (number > max)
      max = number;
 
    if (number < min)
      min = number;
  }
 
  if (all_nan)
    throw std::runtime_error("All values are NaN(Not a Number)");
 
  _minmax_data.recordMinMax(node, min, max);
}

References luci::CircleNode::name(), luci::CircleNode::opcode(), and record_minmax::MinMaxMap::recordMinMax().

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