record_minmax::RecordMinMax Class Reference

#include <RecordMinMax.h>

Public Types
enum	DataSetFormat {   UNKNOWN , RANDOM , H5 , DIRECTORY ,   LIST_FILE }

Public Member Functions
	RecordMinMax (uint32_t num_threads, std::unique_ptr< MinMaxComputer > &&minmax_computer)
	~RecordMinMax ()=default
void	initialize (const std::string &input_model_path)
void	setDataSetFormat (DataSetFormat format)
DataSetFormat	getDataSetFormat () const
void	setInputDataPath (const std::string &input_data_path)
void	profileData ()
void	profileDataInParallel (const std::string &input_data_path)
void	saveModel (const std::string &output_model_path)

Detailed Description

Definition at line 37 of file RecordMinMax.h.

Member Enumeration Documentation

DataSetFormat

enum record_minmax::RecordMinMax::DataSetFormat

Enumerator
UNKNOWN
RANDOM
H5
DIRECTORY
LIST_FILE

Definition at line 40 of file RecordMinMax.h.

  {
    UNKNOWN, // To check if format is set properly
    RANDOM,
    H5,
    DIRECTORY,
    LIST_FILE,
  };

Constructor & Destructor Documentation

RecordMinMax()

record_minmax::RecordMinMax::RecordMinMax ( uint32_t  num_threads, std::unique_ptr< MinMaxComputer > &&  minmax_computer  )

inlineexplicit

Definition at line 49 of file RecordMinMax.h.

    : _threads_size(num_threads), _minmax_computer(std::move(minmax_computer))
  {
    assert(_threads_size > 0);
    assert(_minmax_computer != nullptr);
  }

~RecordMinMax()

record_minmax::RecordMinMax::~RecordMinMax ( )

default

Member Function Documentation

getDataSetFormat()

DataSetFormat record_minmax::RecordMinMax::getDataSetFormat ( ) const

inline

Definition at line 66 of file RecordMinMax.h.

{ return _data_set_format; }

Referenced by profileData().

initialize()

void record_minmax::RecordMinMax::initialize

(

const std::string &

input_model_path

)

Definition at line 75 of file RecordMinMax.cpp.

{
  assert(_threads_size > 0);
 
  luci::ImporterEx importer;
  _module = importer.importVerifyModule(input_model_path);
 
  if (_module == nullptr)
  {
    throw std::runtime_error("Failed to load '" + input_model_path + "'");
  }
 
  // Create and initialize interpreters and observers
  _interpreters.resize(_threads_size);
  _observers.resize(_threads_size);
 
  for (uint32_t thread_idx = 0; thread_idx < _threads_size; ++thread_idx)
  {
    auto interpreter = std::make_unique<luci_interpreter::Interpreter>(_module.get());
    auto observer = std::make_unique<MinMaxObserver>();
 
    interpreter->attachObserver(observer.get());
 
    _observers[thread_idx] = std::move(observer);
    _interpreters[thread_idx] = std::move(interpreter);
  }
}

References luci::ImporterEx::importVerifyModule().

Referenced by entry().

profileData()

void record_minmax::RecordMinMax::profileData

(

)

Definition at line 190 of file RecordMinMax.cpp.

{
  assert(getDataSetFormat() != DataSetFormat::UNKNOWN); // FIX_CALLER_UNLESS
 
  const auto input_nodes = loco::input_nodes(_module->graph());
  for (auto input_node : input_nodes)
  {
    const auto *input_cnode = loco::must_cast<const luci::CircleInput *>(input_node);
    checkInputDimension(input_cnode);
  }
 
  const auto num_inputs = input_nodes.size();
 
  auto iter = createIterator();
 
  bool check_type_shape = iter->check_type_shape();
 
  if (not iter->hasNext())
    throw std::runtime_error("The input data file does not contain any record.");
 
  uint32_t record_idx = 0;
  while (iter->hasNext())
  {
    const auto &record = iter->next();
 
    if (num_inputs != record.size())
      throw std::runtime_error("Wrong number of inputs.");
 
    std::cout << "Recording " << record_idx << "'th data" << std::endl;
 
    // Write input data to interpreter
    for (uint32_t input_idx = 0; input_idx < num_inputs; input_idx++)
    {
      const auto *input_node = loco::must_cast<const luci::CircleInput *>(input_nodes[input_idx]);
      assert(input_node->index() == input_idx);
 
      const auto input_data = record.at(input_idx);
 
      if (check_type_shape)
      {
        // Check the type and the shape of the input data is valid
        verifyTypeShape(input_node, input_data.dtype, input_data.shape);
      }
 
      getInterpreter()->writeInputTensor(input_node, input_data.data.data(),
                                         input_data.data.size());
    }
 
    getInterpreter()->interpret();
 
    record_idx++;
  }
 
  std::cout << "Recording finished. Number of recorded data: " << record_idx << std::endl;
 
  _minmax_computer->update_qparam(getObserver()->minMaxData()->getMap());
}

References record_minmax::checkInputDimension(), getDataSetFormat(), luci::CircleInput::index(), loco::input_nodes(), luci_interpreter::Interpreter::interpret(), UNKNOWN, and luci_interpreter::Interpreter::writeInputTensor().

Referenced by entry().

profileDataInParallel()

void record_minmax::RecordMinMax::profileDataInParallel

(

const std::string &

input_data_path

)

Definition at line 248 of file RecordMinMax.cpp.

{
  LOGGER(l);
 
  assert(_interpreters.size() == _threads_size);
  assert(_observers.size() == _threads_size);
 
  const long h5_file_size = getH5FileSize(input_data_path);
 
  if (h5_file_size > h5_max_size_bytes)
    throw std::runtime_error("H5 file size is too large for parallel recording");
 
  WholeOutput whole_output;
  try
  {
    whole_output = importH5Data(input_data_path);
  }
  catch (const std::bad_alloc &e)
  {
    throw std::runtime_error("Out of memory during h5 data load.");
  }
 
  const auto num_records = whole_output.size();
  const auto input_nodes = loco::input_nodes(_module->graph());
 
  // Start parallel part
  INFO(l) << _threads_size << " concurrent threads are supported." << std::endl;
 
  const auto run_threads = num_records < _threads_size ? num_records : _threads_size;
 
  const auto records_batch = static_cast<uint32_t>(num_records / run_threads);
 
  auto interpret_batch = [&whole_output, &input_nodes](int first_record, int last_record,
                                                       luci_interpreter::Interpreter *interpreter) {
    for (int record_index = first_record; record_index < last_record; ++record_index)
    {
      for (uint32_t input_idx = 0; input_idx < input_nodes.size(); input_idx++)
      {
        const auto *input_node = loco::must_cast<const luci::CircleInput *>(input_nodes[input_idx]);
 
        const auto &cur_input_data = whole_output[record_index][input_idx];
        interpreter->writeInputTensor(input_node, cur_input_data.data(), cur_input_data.size());
      }
      interpreter->interpret();
    }
  };
 
  std::vector<std::thread> threads;
  for (uint32_t t = 0; t < run_threads; ++t)
  {
    if (t < run_threads - 1)
    {
      threads.emplace_back(interpret_batch, records_batch * t, records_batch * (t + 1),
                           _interpreters[t].get());
    }
    else
    {
      threads.emplace_back(interpret_batch, records_batch * t, num_records, _interpreters[t].get());
    }
  }
 
  for (uint32_t i = 0; i < run_threads; ++i)
    threads.at(i).join();
 
  // End parallel part
 
  // Copy all min, max values to one min/max map
  MinMaxMap main_min_max_map;
 
  for (const auto &obs : _observers)
  {
    const auto cur_minmax_map = obs->minMaxData()->getMap();
    for (auto &iter : *cur_minmax_map)
    {
      const auto node = iter.first;
      const auto &minmax = iter.second;
 
      main_min_max_map.appendMinMaxVector(node, minmax);
    }
  }
 
  std::cout << "Recording finished. Number of recorded data: " << num_records << std::endl;
 
  _minmax_computer->update_qparam(main_min_max_map.getMap());
}

References record_minmax::MinMaxMap::appendMinMaxVector(), record_minmax::MinMaxMap::getMap(), INFO, loco::input_nodes(), and LOGGER.

Referenced by entry().

saveModel()

void record_minmax::RecordMinMax::saveModel

(

const std::string &

output_model_path

)

Definition at line 334 of file RecordMinMax.cpp.

{
  // Export to output Circle file
  luci::CircleExporter exporter;
 
  luci::CircleFileExpContract contract(_module.get(), output_model_path);
 
  if (!exporter.invoke(&contract))
  {
    throw std::runtime_error("Failed to export '" + output_model_path + "'");
  }
}

References luci::CircleExporter::invoke().

Referenced by entry().

setDataSetFormat()

void record_minmax::RecordMinMax::setDataSetFormat ( DataSetFormat  format )

inline

Definition at line 60 of file RecordMinMax.h.

  {
    assert(format != DataSetFormat::UNKNOWN); // FIX_CALLER UNLESS
    _data_set_format = format;
  }

References UNKNOWN.

Referenced by entry().

setInputDataPath()

void record_minmax::RecordMinMax::setInputDataPath ( const std::string &  input_data_path )

inline

Definition at line 68 of file RecordMinMax.h.

{ _input_data_path = input_data_path; }

Referenced by entry().

---

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

• compiler/record-minmax/include/RecordMinMax.h
• compiler/record-minmax/src/RecordMinMax.cpp