dalgona::Dalgona Class Reference

#include <Dalgona.h>

Public Member Functions
	Dalgona ()=default
	~Dalgona ()=default
void	initialize (const std::string &input_model_path)
void	runAnalysisWithH5Input (const std::string &input_data_path, const std::string &analysis_path, const std::string &analysis_args)
void	runAnalysisWithRandomInput (const std::string &analysis_path, const std::string &analysis_args)

Detailed Description

Definition at line 30 of file Dalgona.h.

Constructor & Destructor Documentation

Dalgona()

dalgona::Dalgona::Dalgona ( )

explicitdefault

~Dalgona()

dalgona::Dalgona::~Dalgona ( )

default

Member Function Documentation

initialize()

void dalgona::Dalgona::initialize

(

const std::string &

input_model_path

)

Definition at line 99 of file Dalgona.cpp.

{
  luci::ImporterEx importer;
  _module = importer.importVerifyModule(input_model_path);
 
  if (not _module)
    throw std::runtime_error("ERROR: Failed to load '" + input_model_path + "'");
 
  // Initialize interpreter
  _interpreter = std::make_unique<luci_interpreter::Interpreter>(_module.get());
 
  _hooks = std::make_unique<PythonHooks>(_interpreter.get());
 
  _interpreter->attachObserver(_hooks.get());
}

References luci::ImporterEx::importVerifyModule().

runAnalysisWithH5Input()

void dalgona::Dalgona::runAnalysisWithH5Input	(	const std::string &	input_data_path,
		const std::string &	analysis_path,
		const std::string &	analysis_args
	)

Definition at line 115 of file Dalgona.cpp.

{
  py::object scope = py::module::import("__main__").attr("__dict__");
  _hooks->importAnalysis(analysis_path, scope, analysis_args);
 
  try
  {
    dio::hdf5::HDF5Importer importer(input_data_path);
    importer.importGroup("value");
 
    bool is_raw_data = importer.isRawData();
 
    const auto num_records = importer.numData();
    if (num_records == 0)
      throw std::runtime_error("The input data file does not contain any record.");
 
    const auto input_nodes = loco::input_nodes(_module->graph());
    const auto num_inputs = input_nodes.size();
 
    for (int32_t record_idx = 0; record_idx < num_records; record_idx++)
    {
      if (num_inputs != static_cast<uint32_t>(importer.numInputs(record_idx)))
        throw std::runtime_error("Wrong number of inputs.");
 
      std::cout << "Running " << record_idx << "'th data" << std::endl;
 
      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);
        checkInputDimension(input_node);
        std::vector<char> input_data(getByteSize(input_node));
 
        if (is_raw_data)
        {
          // Skip type/shape check for raw data
          importer.readTensor(record_idx, input_idx, input_data.data(), input_data.size());
        }
        else
        {
          DataType dtype;
          Shape shape;
          importer.readTensor(record_idx, input_idx, &dtype, &shape, input_data.data(),
                              input_data.size());
 
          // Check the type and the shape of the input data is valid
          verifyTypeShape(input_node, dtype, shape);
        }
 
        _interpreter->writeInputTensor(input_node, input_data.data(), input_data.size());
      }
 
      _hooks->startNetworkExecution(_module->graph());
      _interpreter->interpret();
      _hooks->endNetworkExecution(_module->graph());
    }
 
    std::cout << "Finished executing " << num_records << "'th data" << std::endl;
    _hooks->endAnalysis();
  }
  catch (const H5::Exception &e)
  {
    H5::Exception::printErrorStack();
    throw std::runtime_error("HDF5 error occurred.");
  }
}

References dio::hdf5::HDF5Importer::importGroup(), luci::CircleInput::index(), loco::input_nodes(), dio::hdf5::HDF5Importer::isRawData(), dio::hdf5::HDF5Importer::numData(), dio::hdf5::HDF5Importer::numInputs(), and dio::hdf5::HDF5Importer::readTensor().

runAnalysisWithRandomInput()

void dalgona::Dalgona::runAnalysisWithRandomInput	(	const std::string &	analysis_path,
		const std::string &	analysis_args
	)

Definition at line 184 of file Dalgona.cpp.

{
  py::object scope = py::module::import("__main__").attr("__dict__");
  _hooks->importAnalysis(analysis_path, scope, analysis_args);
 
  const auto input_nodes = loco::input_nodes(_module->graph());
  const auto num_inputs = input_nodes.size();
 
  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);
    checkInputDimension(input_node);
 
    uint32_t num_elems = numElements(input_node);
    switch (input_node->dtype())
    {
      case DataType::FLOAT32:
      {
        // Synced with record-minmax (-5,5)
        auto input_data = genRandomFloatData(num_elems, -5, 5);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(float));
        break;
      }
      case DataType::U8:
      {
        auto input_data = genRandomIntData<uint8_t>(num_elems, std::numeric_limits<uint8_t>::min(),
                                                    std::numeric_limits<uint8_t>::max());
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(uint8_t));
        break;
      }
      case DataType::S16:
      {
        auto input_data = genRandomIntData<int16_t>(num_elems, std::numeric_limits<int16_t>::min(),
                                                    std::numeric_limits<int16_t>::max());
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(int16_t));
        break;
      }
      case DataType::S32:
      {
        // Synced with record-minmax (0, 100)
        auto input_data = genRandomIntData<int32_t>(num_elems, 0, 100);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(int32_t));
        break;
      }
      case DataType::S64:
      {
        // Synced with record-minmax (0, 100)
        auto input_data = genRandomIntData<int64_t>(num_elems, 0, 100);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(int64_t));
        break;
      }
      case DataType::BOOL:
      {
        // Bool is represented as uint8 (0 or 1)
        auto input_data = genRandomIntData<uint8_t>(num_elems, 0, 1);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(uint8_t));
        break;
      }
      default:
        throw std::runtime_error("Unsupported input data type in " + input_node->name());
    }
  }
 
  _hooks->startNetworkExecution(_module->graph());
  _interpreter->interpret();
  _hooks->endNetworkExecution(_module->graph());
 
  std::cout << "Finished executing a random input" << std::endl;
  _hooks->endAnalysis();
}

References dalgona::genRandomFloatData(), luci::CircleInput::index(), loco::input_nodes(), luci::CircleNode::name(), and num_elems().

---

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

• compiler/dalgona/include/Dalgona.h
• compiler/dalgona/src/Dalgona.cpp