onert::loader Namespace Reference

Namespaces
namespace	train

Data Structures
class	BaseLoader
class	ILoader

Functions
std::unique_ptr< ir::Model >	loadCircleModel (const std::string &filename)
std::unique_ptr< ir::Model >	loadCircleModel (uint8_t *buffer, size_t size)
std::unique_ptr< ir::Model >	loadModel (const std::string &filename, const std::string &type)
	Create custom loader and load model from file.
std::unique_ptr< ir::Model >	loadTFLiteModel (const std::string &filename)
std::unique_ptr< ir::train::TrainingInfo >	loadTrainingInfo (const uint8_t *buffer, const size_t size)
template<typename T >
bool	Copy (const T *data_ptr, std::vector< uint16_t > &arr)

Variables
const char *const	TRAININFO_METADATA_NAME = "CIRCLE_TRAINING"

Function Documentation

Copy()

template<typename T >

bool onert::loader::Copy	(	const T *	data_ptr,
		std::vector< uint16_t > &	arr
	)

Definition at line 346 of file BaseLoader.h.

{
  if (data_ptr->values() == nullptr)
  {
    return false;
  }
 
  int size = data_ptr->values()->size();
  arr.reserve(size);
  for (int i = 0; i < size; i++)
  {
    arr.emplace_back(static_cast<uint16_t>(data_ptr->values()->Get(i)));
  }
  return true;
}

References size.

Referenced by onert::loader::BaseLoader< LoaderDomain >::loadSparsity().

loadCircleModel() [1/2]

std::unique_ptr< ir::Model > onert::loader::loadCircleModel

(

const std::string &

filename

)

Definition at line 285 of file CircleLoader.cc.

{
  auto model = std::make_unique<ir::Model>();
  CircleLoader loader(model);
  loader.loadFromFile(filename);
  return model;
}

Referenced by nnfw_session::load_circle_from_buffer().

loadCircleModel() [2/2]

std::unique_ptr< ir::Model > onert::loader::loadCircleModel	(	uint8_t *	buffer,
		size_t	size
	)

Definition at line 293 of file CircleLoader.cc.

{
  auto model = std::make_unique<ir::Model>();
  CircleLoader loader(model);
  loader.loadFromBuffer(buffer, size);
  return model;
}

References size.

loadModel()

std::unique_ptr< ir::Model > onert::loader::loadModel	(	const std::string &	filename,
		const std::string &	type
	)

Create custom loader and load model from file.

Parameters

[in]	filename	File path to load model from
[in]	type	Type of model to load

Returns

Loaded model.

Note

Throw exception if failed to load model

Definition at line 28 of file ModelLoader.cc.

{
  // Custom loader library name should be lib<type>_loader.so
  std::string libname = "lib" + type + "_loader.so";
 
  // Open custom loader library
  void *handle = dlopen(libname.c_str(), RTLD_LAZY);
  if (!handle)
    throw std::runtime_error("Failed to open " + type + " loader");
 
  // Get custom loader create function
  using create_func_t = ILoader *(*)();
  auto create_fn = reinterpret_cast<create_func_t>(dlsym(handle, "onert_loader_create"));
  if (!create_fn)
  {
    dlclose(handle);
    throw std::runtime_error("Failed to find loader create function");
  }
 
  // Get custom loader destroy function
  using destroy_func_t = void (*)(ILoader *);
  auto destroy_fn = reinterpret_cast<destroy_func_t>(dlsym(handle, "onert_loader_destroy"));
  if (!destroy_fn)
  {
    dlclose(handle);
    throw std::runtime_error("Failed to find loader destroy function");
  }
 
  // Create custom loader
  auto loader = create_fn();
  if (!loader)
  {
    dlclose(handle);
    throw std::runtime_error("Failed to find loader create function");
  }
 
  // Load model
  auto model = loader->loadFromFile(filename);
 
  // Destroy custom loader
  destroy_fn(loader);
 
  // Close custom loader library
  //
  // NOTE:
  //  It assumes that custom loader will not be used frequently on runtime session.
  //  If custom loader is used frequently, it should not close custom loader library and
  //  save handler to reuse it.
  dlclose(handle);
 
  if (model)
    return model;
 
  throw std::runtime_error("Failed to load model " + filename);
}

loadTFLiteModel()

std::unique_ptr< ir::Model > onert::loader::loadTFLiteModel

(

const std::string &

filename

)

Definition at line 158 of file TFLiteLoader.cc.

{
  auto model = std::make_unique<ir::Model>();
  TFLiteLoader loader(model);
  loader.loadFromFile(filename);
  return model;
}

loadTrainingInfo()

std::unique_ptr< ir::train::TrainingInfo > onert::loader::loadTrainingInfo	(	const uint8_t *	buffer,
		const size_t	size
	)

Definition at line 113 of file TrainInfoLoader.cc.

{
  assert(buffer != nullptr);
 
  flatbuffers::Verifier v(buffer, size);
  bool verified = circle::VerifyModelTrainingBuffer(v);
  if (not verified)
    throw std::runtime_error{"TrainingInfo buffer is not accessible"};
 
  const circle::ModelTraining *circle_model =
    circle::GetModelTraining(static_cast<const void *>(buffer));
 
  assert(circle_model != nullptr);
 
  auto tinfo = std::make_unique<ir::train::TrainingInfo>();
  {
    tinfo->setVersion(circle_model->version());
    tinfo->setBatchSize(circle_model->batch_size());
    tinfo->setOptimizerInfo(loadOptimizerInfo(circle_model));
    tinfo->setLossInfo(loadLossInfo(circle_model));
    tinfo->setTrainableOps(loadTrainableOps(circle_model));
  }
  return tinfo;
}

References size.

Variable Documentation

TRAININFO_METADATA_NAME

const char *const onert::loader::TRAININFO_METADATA_NAME = "CIRCLE_TRAINING"

Definition at line 27 of file TrainInfoLoader.cc.