nnfw_session Struct Reference

#include <nnfw_session.h>

Public Member Functions
	~nnfw_session ()
NNFW_STATUS	load_model_from_file (const char *package_file_path)
NNFW_STATUS	train_set_traininfo (const nnfw_train_info *info)
NNFW_STATUS	train_prepare ()
NNFW_STATUS	train_input_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	train_expected_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	train_set_input (uint32_t index, void *input)
NNFW_STATUS	train_set_expected (uint32_t index, void *expected)
NNFW_STATUS	train_set_output (uint32_t index, NNFW_TYPE type, void *buffer, size_t length)
NNFW_STATUS	train_run (bool update_weights)
NNFW_STATUS	train_get_loss (uint32_t index, float *loss)
NNFW_STATUS	train_export_circle (const char *path)
NNFW_STATUS	train_export_checkpoint (const char *path)
NNFW_STATUS	train_import_checkpoint (const char *path)
	~nnfw_session ()
NNFW_STATUS	load_model_from_path (const char *path)
NNFW_STATUS	prepare ()
NNFW_STATUS	run ()
NNFW_STATUS	run_async ()
NNFW_STATUS	await ()
NNFW_STATUS	set_input (uint32_t index, NNFW_TYPE type, const void *buffer, size_t length)
NNFW_STATUS	set_output (uint32_t index, NNFW_TYPE type, void *buffer, size_t length)
NNFW_STATUS	input_size (uint32_t *number)
NNFW_STATUS	output_size (uint32_t *number)
NNFW_STATUS	set_input_layout (uint32_t index, NNFW_LAYOUT layout)
NNFW_STATUS	set_output_layout (uint32_t index, NNFW_LAYOUT layout)
NNFW_STATUS	set_input_tensorinfo (uint32_t index, const nnfw_tensorinfo *ti)
NNFW_STATUS	input_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	output_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	set_available_backends (const char *backends)
NNFW_STATUS	set_workspace (const char *dir)
NNFW_STATUS	set_config (const char *key, const char *value)
NNFW_STATUS	get_config (const char *key, char *value, size_t value_size)
NNFW_STATUS	load_circle_from_buffer (uint8_t *buffer, size_t size)
NNFW_STATUS	register_custom_operation (const std::string &id, nnfw_custom_eval eval_func)
NNFW_STATUS	input_tensorindex (const char *tensorname, uint32_t *index)
NNFW_STATUS	output_tensorindex (const char *tensorname, uint32_t *index)
NNFW_STATUS	run_with_auto_compilation (const char *target, NNFW_CODEGEN_PREF pref)
NNFW_STATUS	set_odc_param_minmax_records_count (int minmax_records_count)
NNFW_STATUS	delete_odc_minmax_file ()
NNFW_STATUS	set_backends_per_operation (const char *backend_settings)
	Set backends with string-encoded mapping from operation index to backend type (cpu, acl_cl)
NNFW_STATUS	train_get_traininfo (nnfw_train_info *info)
NNFW_STATUS	train_set_traininfo (const nnfw_train_info *info)
NNFW_STATUS	train_prepare ()
NNFW_STATUS	train_input_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	train_expected_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	train_set_input (uint32_t index, const void *input, const nnfw_tensorinfo *input_tensorinfo)
NNFW_STATUS	train_set_expected (uint32_t index, const void *expected, const nnfw_tensorinfo *expected_tensorinfo)
NNFW_STATUS	train_set_output (uint32_t index, NNFW_TYPE type, void *buffer, size_t length)
NNFW_STATUS	train_run (bool update_weights)
NNFW_STATUS	train_get_loss (uint32_t index, float *loss)
NNFW_STATUS	train_export_circle (const char *path)
NNFW_STATUS	train_export_circleplus (const char *path)
NNFW_STATUS	train_import_checkpoint (const char *path)
NNFW_STATUS	train_export_checkpoint (const char *path)
NNFW_STATUS	set_quantization_type (NNFW_QUANTIZE_TYPE qtype)
NNFW_STATUS	set_quantized_model_path (const char *path)
NNFW_STATUS	quantize ()
NNFW_STATUS	set_codegen_model_path (const char *path)
NNFW_STATUS	codegen (const char *target, NNFW_CODEGEN_PREF pref)
NNFW_STATUS	set_prepare_config (const NNFW_PREPARE_CONFIG key, const char *value)
NNFW_STATUS	reset_prepare_config ()
NNFW_STATUS	set_execute_config (const NNFW_RUN_CONFIG key, const char *value)
NNFW_STATUS	reset_execute_config ()

Static Public Member Functions
static NNFW_STATUS	create (nnfw_session **session)
	Factory method. It creates and initialize nnfw_session.
static NNFW_STATUS	create (nnfw_session **session)
	Factory method. It creates and initialize nnfw_session.
static NNFW_STATUS	deprecated (const char *msg)

Detailed Description

Definition at line 68 of file onert-micro.cpp.

Constructor & Destructor Documentation

~nnfw_session() [1/2]

nnfw_session::~nnfw_session ( )

default

Definition at line 165 of file onert-micro.cpp.

{ delete _train_interpreter; }

~nnfw_session() [2/2]

nnfw_session::~nnfw_session

(

)

Member Function Documentation

await()

NNFW_STATUS nnfw_session::await

(

)

Definition at line 508 of file nnfw_session.cc.

{
  if (!isStateRunning())
  {
    std::cerr << "Error during nnfw_session::run_await : "
              << "run_await should be run after run_async" << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  _execution->waitFinish();
 
  _state = State::FINISHED_RUN;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_NO_ERROR.

codegen()

NNFW_STATUS nnfw_session::codegen	(	const char *	target,
		NNFW_CODEGEN_PREF	pref
	)

Definition at line 1868 of file nnfw_session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      std::cerr << "Error during nnfw_session::codegen : Invalid state" << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    std::string target_str{target};
    if (target_str.empty() || target_str.size() < 5 ||
        target_str.substr(target_str.size() - 4) != "-gen")
    {
      std::cerr << "Error during nnfw_session::codegen : Invalid target" << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    onert::odc::CodegenPreference codegen_pref;
    switch (pref)
    {
      case NNFW_CODEGEN_PREF_DEFAULT:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_DEFAULT;
        break;
      case NNFW_CODEGEN_PREF_PERFORMANCE_FIRST:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_PERFORMANCE_FIRST;
        break;
      case NNFW_CODEGEN_PREF_MEMORY_FIRST:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_MEMORY_FIRST;
        break;
      case NNFW_CODEGEN_PREF_COMPILE_TIME_FIRST:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_COMPILE_TIME_FIRST;
        break;
      default:
        std::cerr << "Error during nnfw_session::codegen : Invalid preference" << std::endl;
        return NNFW_STATUS_ERROR;
    }
 
    assert(_codegen_manager != nullptr);
    auto export_model_path = std::filesystem::path(_codegen_manager->exportModelPath());
    const auto model_type = target_str.substr(0, target_str.size() - 4);
    // If the export_model_path is not set, it generates a compiled model path
    // automatically.
    if (export_model_path.empty())
    {
      // The compiled model path is the same directory of the original model/package with
      // target backend extension.
      export_model_path = _model_path.replace_extension(model_type);
      _codegen_manager->exportModelPath(export_model_path.string());
    }
 
    _codegen_manager->codegen(_model_path, target, codegen_pref);
 
    // Replace model
    // TODO Support buffer replace, not file reload
    return loadModelFile(export_model_path, model_type);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::compile : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
}

References onert::odc::CODEGEN_PREF_COMPILE_TIME_FIRST, onert::odc::CODEGEN_PREF_DEFAULT, onert::odc::CODEGEN_PREF_MEMORY_FIRST, onert::odc::CODEGEN_PREF_PERFORMANCE_FIRST, NNFW_CODEGEN_PREF_COMPILE_TIME_FIRST, NNFW_CODEGEN_PREF_DEFAULT, NNFW_CODEGEN_PREF_MEMORY_FIRST, NNFW_CODEGEN_PREF_PERFORMANCE_FIRST, NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

Referenced by run_with_auto_compilation().

create() [1/2]

NNFW_STATUS nnfw_session::create ( nnfw_session **  session )

static

Factory method. It creates and initialize nnfw_session.

Note

Use factory instead of constructor to get status

Definition at line 149 of file onert-micro.cpp.

{
  if (session == nullptr)
    return NNFW_STATUS_UNEXPECTED_NULL;
 
  auto new_session = std::unique_ptr<nnfw_session>(new nnfw_session());
  *session = new_session.release();
 
  if (*session == nullptr)
  {
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

Referenced by nnfw_create_session().

create() [2/2]

static NNFW_STATUS nnfw_session::create ( nnfw_session **  session )

static

Factory method. It creates and initialize nnfw_session.

Note

Use factory instead of constructor to get status

delete_odc_minmax_file()

NNFW_STATUS nnfw_session::delete_odc_minmax_file

(

)

Definition at line 2024 of file nnfw_session.cc.

{
  if (isStateRunning())
  {
    std::cerr << "invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (_quant_manager->deleteMinMaxFile())
    return NNFW_STATUS_NO_ERROR;
  else
    return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

deprecated()

NNFW_STATUS nnfw_session::deprecated ( const char *  msg )

static

Definition at line 870 of file nnfw_session.cc.

{
  std::cerr << msg << std::endl;
  return NNFW_STATUS_DEPRECATED_API;
}

References NNFW_STATUS_DEPRECATED_API.

Referenced by nnfw_apply_tensorinfo(), nnfw_pop_pipeline_output(), nnfw_prepare_pipeline(), nnfw_push_pipeline_input(), and nnfw_set_op_backend().

get_config()

NNFW_STATUS nnfw_session::get_config	(	const char *	key,
		char *	value,
		size_t	value_size
	)

Definition at line 971 of file nnfw_session.cc.

{
  if (!isStateModelLoaded())
    return NNFW_STATUS_INVALID_STATE;
 
  if (!key || !value)
    return NNFW_STATUS_UNEXPECTED_NULL;
 
  auto check_boundary = [](size_t dest_size, std::string &src) {
    if (dest_size < src.length() + 1 /* for '\0' */)
    {
      std::cerr << "buffer is small to copy config value." << std::endl;
      return false;
    }
    return true;
  };
 
  const std::string skey = key;
 
  if (skey == onert::util::config::BACKENDS)
  {
    if (_coptions->backend_list.size() == 0)
      return NNFW_STATUS_NO_ERROR; // no setting backend is not an error of get_config_str()
 
    auto str =
      nnfw::misc::join(_coptions->backend_list.begin(), _coptions->backend_list.end(), ";");
 
    if (!check_boundary(value_size, str))
      return NNFW_STATUS_ERROR;
 
    strncpy(value, str.c_str(), value_size);
  }
  else if (skey == onert::util::config::EXECUTOR)
  {
    if (!check_boundary(value_size, _coptions->executor))
      return NNFW_STATUS_ERROR;
 
    strncpy(value, _coptions->executor.c_str(), _coptions->executor.length());
  }
  else
  {
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References nnfw::misc::join(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

input_size()

NNFW_STATUS nnfw_session::input_size

(

uint32_t *

number

)

Definition at line 588 of file nnfw_session.cc.

{
  if (isStateInitialized()) // Model is not loaded
    return NNFW_STATUS_INVALID_STATE;
 
  try
  {
    if (number == nullptr)
    {
      std::cerr << "Error during nnfw_session::input_size, number is null pointer." << std::endl;
      return NNFW_STATUS_UNEXPECTED_NULL;
    }
    *number = getInputSize();
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::input_size : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

Referenced by run_with_auto_compilation().

input_tensorindex()

NNFW_STATUS nnfw_session::input_tensorindex	(	const char *	tensorname,
		uint32_t *	index
	)

Definition at line 1090 of file nnfw_session.cc.

{
  return getTensorIndexImpl(*primary_subgraph(), tensorname, index, true);
}

input_tensorinfo()

NNFW_STATUS nnfw_session::input_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 739 of file nnfw_session.cc.

{
  if (isStateInitialized())
    return NNFW_STATUS_INVALID_STATE;
 
  try
  {
    if (ti == nullptr)
    {
      std::cerr << "Error during nnfw_session::input_tensorinfo, tensorinfo is null pointer."
                << std::endl;
      return NNFW_STATUS_UNEXPECTED_NULL;
    }
 
    if (index >= getInputSize())
    {
      std::cerr << "Error during nnfw_session::input_tensorinfo, index is out of range."
                << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    if (isStateModelLoaded())
    {
      auto info = _nnpkg->inputInfo(index);
      fillTensorInfo(ti, info.shape(), info.typeInfo().type());
    }
    else
    {
      auto io_index = onert::ir::IOIndex{index};
      auto shape = _execution->getInputShape(io_index);
      auto dtype = _compiler_artifact->_executors->inputInfo(io_index).typeInfo().type();
      fillTensorInfo(ti, shape, dtype);
    }
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::input_tensorinfo : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References info, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

Referenced by run_with_auto_compilation(), package.infer.session::set_inputs(), and train_set_input().

load_circle_from_buffer()

NNFW_STATUS nnfw_session::load_circle_from_buffer	(	uint8_t *	buffer,
		size_t	size
	)

Definition at line 277 of file nnfw_session.cc.

{
  if (!isStateInitialized())
    return NNFW_STATUS_INVALID_STATE;
 
  if (!buffer)
    return NNFW_STATUS_UNEXPECTED_NULL;
 
  if (size == 0)
    return NNFW_STATUS_ERROR;
 
  try
  {
    auto model = onert::loader::loadCircleModel(buffer, size);
    // TODO: Update _model_path if necessary
    _nnpkg = std::make_shared<onert::ir::NNPkg>(std::move(model));
    _train_info = loadTrainingInfo(_nnpkg->primary_model());
    _state = State::MODEL_LOADED;
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during model loading : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References onert::loader::loadCircleModel(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and size.

load_model_from_file()

NNFW_STATUS nnfw_session::load_model_from_file

(

const char *

package_file_path

)

Definition at line 272 of file onert-micro.cpp.

{
  _model_buf = readFile(file_path);
  _config.model_ptr = _model_buf.data();
  _config.model_size = _model_buf.size();
  // load training info
  loadTrainingInfo(_config.model_ptr);
  // TODO: this import should start on nnfw_prepare if inference_interpreter is introduced
  _train_interpreter->importTrainModel(_config.model_ptr, _config);
  return NNFW_STATUS_NO_ERROR;
}

References onert_micro::OMTrainingInterpreter::importTrainModel(), onert_micro::OMConfig::model_ptr, onert_micro::OMConfig::model_size, NNFW_STATUS_NO_ERROR, and readFile().

load_model_from_path()

NNFW_STATUS nnfw_session::load_model_from_path

(

const char *

path

)

Definition at line 304 of file nnfw_session.cc.

{
  if (!isStateInitialized())
    return NNFW_STATUS_INVALID_STATE;
 
  if (!path)
  {
    std::cerr << "Path is null." << std::endl;
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!null_terminating(path, MAX_PATH_LENGTH))
  {
    std::cerr << "Path is too long" << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    std::filesystem::path filename{path};
    if (!std::filesystem::is_directory(filename) && filename.has_extension())
    {
      std::string model_type = filename.extension().string().substr(1); // + 1 to exclude dot
      return loadModelFile(filename, model_type);
    }
 
    const auto &package_dir = filename;
 
    // TODO : add support for zipped package file load
    if (!std::filesystem::is_directory(package_dir))
    {
      std::cerr << "invalid path: " << package_dir << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    const auto manifest_file_name = package_dir / "metadata/MANIFEST";
    std::ifstream mfs(manifest_file_name);
 
    // extract the filename of the first(index 0) model
    // e.g. In MANIFEST file, { "models" : [ "firstmodel.tflite", "2nd.tflite" ] }
    Json::Value root;
    mfs >> root;
    const Json::Value &models = root["models"];
    const Json::Value &model_types = root["model-types"];
    const Json::Value &configs = root["configs"];
 
    if (!configs.empty() && !configs[0].empty())
    {
      const auto filepath = package_dir / "metadata" / configs[0].asString();
 
      onert::util::CfgKeyValues keyValues;
      if (loadConfigure(filepath.string(), keyValues))
      {
        onert::util::setConfigKeyValues(keyValues);
      }
    }
    _nnpkg = std::make_shared<onert::ir::NNPkg>();
    auto num_models = models.size();
    if (num_models == 0 || (num_models - 1) > onert::ir::ModelIndex::max())
    {
      std::cerr << "Invalid model size - " << std::to_string(num_models) << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    // Not support backend mapping to operator index for multiple models yet
    // TODO Support this
    if (num_models > 1 && _coptions->manual_scheduler_options.index_to_backend.size() != 0)
    {
      std::cerr << "Cannot set backend to operator index for multiple models" << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    for (uint16_t i = 0; i < num_models; ++i)
    {
      const auto model_file_path = package_dir / models[i].asString();
      const auto model_type = model_types[i].asString();
      auto model = loadModel(model_file_path.string(), model_type);
      if (model == nullptr)
        return NNFW_STATUS_ERROR;
      _model_path = model_file_path; // TODO Support multiple models
      model->bindKernelBuilder(_kernel_registry->getBuilder());
      _nnpkg->push(onert::ir::ModelIndex{i}, std::move(model));
    }
 
    _train_info = loadTrainingInfo(_nnpkg->primary_model());
 
    auto toIODesc = [](std::string str) {
      auto indices = nnfw::misc::split(str, ':');
      if (indices.size() != 3)
      {
        std::cerr << "IODesc should be 3-tuple." << std::endl;
        return onert::ir::IODesc{};
      }
      auto model_idx = static_cast<uint32_t>(std::stoi(indices.at(0)));
      auto subgraph_idx = static_cast<uint32_t>(std::stoi(indices.at(1)));
      auto operand_idx = static_cast<uint32_t>(std::stoi(indices.at(2)));
      return onert::ir::IODesc{model_idx, subgraph_idx, operand_idx};
    };
    // read pkg-inputs and pkg-outputs
    const Json::Value &pkg_inputs = root["pkg-inputs"];
    for (uint32_t i = 0; i < pkg_inputs.size(); ++i)
      _nnpkg->addInput(toIODesc(pkg_inputs[i].asString()));
    const Json::Value &pkg_outputs = root["pkg-outputs"];
    for (uint32_t i = 0; i < pkg_outputs.size(); ++i)
      _nnpkg->addOutput(toIODesc(pkg_outputs[i].asString()));
    // read model-connect
    const Json::Value &fromtos = root["model-connect"];
    for (uint32_t i = 0; i < fromtos.size(); ++i)
    {
      const Json::Value &tos = fromtos[i]["to"];
      for (uint32_t j = 0; j < tos.size(); ++j)
        _nnpkg->addEdge(toIODesc(fromtos[i]["from"].asString()), toIODesc(tos[j].asString()));
    }
 
    _nnpkg->verify();
    _state = State::MODEL_LOADED;
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during model loading : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References onert::util::Index< uint16_t, ModelIndexTag >::max(), MAX_PATH_LENGTH, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, onert::util::setConfigKeyValues(), and nnfw::misc::split().

output_size()

NNFW_STATUS nnfw_session::output_size

(

uint32_t *

number

)

Definition at line 610 of file nnfw_session.cc.

{
  if (isStateInitialized()) // Model is not loaded
    return NNFW_STATUS_INVALID_STATE;
 
  try
  {
    if (number == nullptr)
    {
      std::cerr << "Error during nnfw_session::output_size, number is null pointer." << std::endl;
      return NNFW_STATUS_UNEXPECTED_NULL;
    }
    *number = getOutputSize();
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::output_size" << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

Referenced by run_with_auto_compilation().

output_tensorindex()

NNFW_STATUS nnfw_session::output_tensorindex	(	const char *	tensorname,
		uint32_t *	index
	)

Definition at line 1095 of file nnfw_session.cc.

{
  return getTensorIndexImpl(*primary_subgraph(), tensorname, index, false);
}

output_tensorinfo()

NNFW_STATUS nnfw_session::output_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 781 of file nnfw_session.cc.

{
  if (isStateInitialized())
    return NNFW_STATUS_INVALID_STATE;
 
  if (ti == nullptr)
  {
    std::cerr << "Error during nnfw_session::output_tensorinfo, tensorinfo is null pointer."
              << std::endl;
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  try
  {
    if (index >= getOutputSize())
    {
      std::cerr << "Error during nnfw_session::output_tensorinfo, index is out of range."
                << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    if (isStateModelLoaded())
    {
      auto info = _nnpkg->outputInfo(index);
      fillTensorInfo(ti, info.shape(), info.typeInfo().type());
    }
    else
    {
      auto io_index = onert::ir::IOIndex{index};
      auto shape = _execution->getOutputShape(io_index);
      auto dtype = _compiler_artifact->_executors->outputInfo(io_index).typeInfo().type();
      fillTensorInfo(ti, shape, dtype);
    }
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::output_tensorinfo : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References info, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

Referenced by run_with_auto_compilation(), and package.infer.session::set_outputs().

prepare()

NNFW_STATUS nnfw_session::prepare

(

)

Definition at line 429 of file nnfw_session.cc.

{
  // NOTE. If users want to run prepare() more than one time, this could be removed.
  if (!isStateModelLoaded())
  {
    std::cerr << "Error during model prepare : ";
    if (isStateInitialized())
    {
      std::cerr << "prepare should be run once";
    }
    else
    {
      std::cerr << "invalid state";
    }
    std::cerr << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    auto compiler = onert::compiler::CompilerFactory::get().create(_nnpkg, _coptions.get());
    _nnpkg.reset();
    _compiler_artifact = compiler->compile();
    _execution = std::make_unique<onert::exec::Execution>(_compiler_artifact->_executors);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during model prepare : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  _state = State::PREPARED;
  return NNFW_STATUS_NO_ERROR;
}

References onert::compiler::CompilerFactory::create(), onert::compiler::CompilerFactory::get(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

Referenced by run_with_auto_compilation().

quantize()

NNFW_STATUS nnfw_session::quantize

(

)

Definition at line 1821 of file nnfw_session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      std::cerr << "invalid state" << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    auto result = _quant_manager->quantize(_model_path.string());
    if (!result)
      return NNFW_STATUS_INVALID_STATE;
 
    // Replace model
    // TODO Support buffer replace, not file reload
    return loadModelFile(_quant_manager->exportModelPath(), "circle");
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::quantize : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

register_custom_operation()

NNFW_STATUS nnfw_session::register_custom_operation	(	const std::string &	id,
		nnfw_custom_eval	eval_func
	)

Definition at line 824 of file nnfw_session.cc.

{
  _kernel_registry->registerKernel(id, eval_func);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR.

reset_execute_config()

NNFW_STATUS nnfw_session::reset_execute_config

(

)

Definition at line 1995 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::set_execution_config : Invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _execution->executionOptions().dump_minmax = false;
  _execution->executionOptions().trace = false;
  _execution->executionOptions().profile = false;
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

reset_prepare_config()

NNFW_STATUS nnfw_session::reset_prepare_config

(

)

Definition at line 1952 of file nnfw_session.cc.

{
  if (!isStateModelLoaded())
  {
    std::cerr << "Error during nnfw_session::reset_prepare_config : Invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _coptions->he_profiling_mode = false;
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

run()

NNFW_STATUS nnfw_session::run

(

)

Definition at line 464 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::run : "
              << "run should be run after prepare" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    _execution->execute();
  }
  catch (const onert::InsufficientBufferSizeException &e)
  {
    // Currently insufficient buffer always means output buffer.
    std::cerr << "Error during nnfw_session::run : " << e.what() << std::endl;
    return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::run : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  _state = State::FINISHED_RUN;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and onert::OnertException::what().

Referenced by package.infer.session::inference().

run_async()

NNFW_STATUS nnfw_session::run_async

(

)

Definition at line 493 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::run_async : "
              << "run_async should be run after prepare" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _execution->startExecute();
 
  _state = State::RUNNING;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

run_with_auto_compilation()

NNFW_STATUS nnfw_session::run_with_auto_compilation	(	const char *	target,
		NNFW_CODEGEN_PREF	pref
	)

Definition at line 2039 of file nnfw_session.cc.

{
 
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::run_with_auto_compilation : "
              << "run should be after preparation" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Check quantization and code-generation parameters
  std::string target_str{target};
  if (_quant_manager->exportModelPath().empty() || _codegen_manager->exportModelPath().empty() ||
      target_str.empty() || target_str.substr(target_str.size() - 4) != "-gen")
  {
    std::cerr << "Error during nnfw_session::run_with_auto_compilation : "
              << "quantization and code generation parameters should be set" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Odc: auto compilation with hidden switching mechanizm
  // Check is model already quantized or compiled
  std::ifstream file_quantized_model(_quant_manager->exportModelPath());
  std::ifstream file_compiled_model(_codegen_manager->exportModelPath());
 
  if (!file_quantized_model.good() && !file_compiled_model.good())
  {
    // Run float model and try to quantize it
    {
      // Save execution options
      auto saved_options = _execution->executionOptions();
      // turn on minmax recording
      _execution->executionOptions().dump_minmax = true;
 
      try
      {
        _execution->execute();
      }
      catch (const onert::InsufficientBufferSizeException &e)
      {
        // Currently insufficient buffer always means output buffer.
        std::cerr << "Error during nnfw_session::run_with_auto_compilation : " << e.what()
                  << std::endl;
        return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
      }
      catch (const std::exception &e)
      {
        std::cerr << "Error during nnfw_session::run_with_auto_compilation : " << e.what()
                  << std::endl;
        return NNFW_STATUS_ERROR;
      }
 
      _state = State::FINISHED_RUN;
 
      // restore min_max option to user defined state
      _execution->executionOptions().dump_minmax = saved_options.dump_minmax;
 
      // if enough statistics are collected, then run the quantization
      if (_quant_manager->readyForQuantize())
      {
        try
        {
          if (isStateInitialized() || isStateRunning())
          {
            std::cerr << "invalid state" << std::endl;
            return NNFW_STATUS_INVALID_STATE;
          }
 
          auto result = _quant_manager->quantize(_model_path);
          if (!result)
            return NNFW_STATUS_INVALID_STATE;
 
          // remove minmax file
          result = _quant_manager->deleteMinMaxFile();
          if (!result)
            return NNFW_STATUS_INVALID_STATE;
        }
        catch (const std::exception &e)
        {
          std::cerr
            << "Error during nnfw_session::run_with_auto_compilation in quantize operation: "
            << e.what() << std::endl;
          return NNFW_STATUS_ERROR;
        }
      }
    }
  }
  else
  {
    // run compiled or quantized model
    NNFW_STATUS status;
 
    // turn off minmax recording
    _execution->executionOptions().dump_minmax = false;
 
    // save initial buffers if quantized model or compiled model is not loaded
    if (_autoCompilationState == nnfw_session::AutoCompilationState::INITIAL_STATE)
    {
      auto dotidx = _codegen_manager->exportModelPath().rfind('.');
      if (dotidx == std::string::npos)
      {
        std::cerr << "Error during nnfw_session::run_with_auto_compilation : Invalid compiled "
                     "model path. Please use a "
                     "path that includes the extension."
                  << std::endl;
        return NNFW_STATUS_ERROR;
      }
 
      std::string compiled_model_type =
        _codegen_manager->exportModelPath().substr(dotidx + 1); // + 1 to exclude dot
 
      dotidx = _quant_manager->exportModelPath().rfind('.');
      if (dotidx == std::string::npos)
      {
        std::cerr << "Error during nnfw_session::run_with_auto_compilation : Invalid quantized "
                     "model path. Please use a "
                     "path that includes the extension."
                  << std::endl;
        return NNFW_STATUS_ERROR;
      }
      std::string quantized_model_type =
        _quant_manager->exportModelPath().substr(dotidx + 1); // + 1 to exclude dot
 
      // Save initial (float) input and output buffers
      auto input_size = _compiler_artifact->_executors->inputSize();
      auto output_size = _compiler_artifact->_executors->outputSize();
 
      std::vector<const void *> _input_buffers;
      std::vector<void *> _output_buffers;
 
      // Save Inputs buffers
      for (size_t input_index = 0; input_index < input_size; input_index++)
      {
        auto io_input_index = onert::ir::IOIndex(input_index);
        auto input_Shape = _execution->getInputShape(io_input_index);
        auto input_buffer = _execution->getInputBuffer(io_input_index);
 
        _input_buffers.push_back(input_buffer);
      }
 
      // Save Outputs buffers
      for (size_t output_index = 0; output_index < output_size; output_index++)
      {
        auto io_output_index = onert::ir::IOIndex(output_index);
 
        auto output_Shape = _execution->getOutputShape(io_output_index);
        auto output_buffer = _execution->getOutputBuffer(io_output_index);
 
        _output_buffers.push_back(output_buffer);
      }
 
      // Save execution options
      auto saved_options = _execution->executionOptions();
 
      // if there is compiled model - try to load it
      if (file_compiled_model.good())
      {
        // load compiled model
        status = loadModelFile(_codegen_manager->exportModelPath(), compiled_model_type);
        if (status == NNFW_STATUS_NO_ERROR)
        {
          _autoCompilationState = nnfw_session::AutoCompilationState::COMPILED_MODEL_LOADED;
        }
      }
      else // there is no compiled model - try to compile and load it
      {
 
        // avoiding code duplication use existing "codegen" function. Set up _model_path for the
        // codegen function.
        // TODO: change it if codegen function will be generalized
        _model_path = _quant_manager->exportModelPath();
 
        // try to compile and load compiled model
        status = codegen(target, pref);
        if (status == NNFW_STATUS_NO_ERROR)
        {
          _autoCompilationState = nnfw_session::AutoCompilationState::COMPILED_MODEL_LOADED;
          // TODO delete quantized model
        }
      }
 
      // loading compiled model is fail - try to load quantized model
      if (_autoCompilationState != nnfw_session::AutoCompilationState::COMPILED_MODEL_LOADED)
      {
        // load quantized model
        status = loadModelFile(_quant_manager->exportModelPath(), quantized_model_type);
        if (status != NNFW_STATUS_NO_ERROR)
          return status;
        else
          _autoCompilationState = nnfw_session::AutoCompilationState::QUANTIZED_MODEL_LOADED;
      }
 
      status = prepare();
      if (status != NNFW_STATUS_NO_ERROR)
        return status;
 
      // Restore execution options
      _execution->executionOptions() = saved_options;
 
      // Restore inputs to the quantized or compiled model
      for (uint32_t input_index = 0; input_index < _input_buffers.size(); input_index++)
      {
        nnfw_tensorinfo ti;
        status = input_tensorinfo(input_index, &ti);
        if (status != NNFW_STATUS_NO_ERROR)
          return status;
 
        ti.dtype = NNFW_TYPE_TENSOR_FLOAT32;
        auto input_size_in_bytes = getBufSize(&ti);
 
        status = set_input(input_index, ti.dtype, _input_buffers[input_index], input_size_in_bytes);
 
        if (status != NNFW_STATUS_NO_ERROR)
          return status;
      }
 
      // Restore outputs to the quantized or compiled model
      for (uint32_t output_index = 0; output_index < _output_buffers.size(); output_index++)
      {
 
        nnfw_tensorinfo ti;
        status = output_tensorinfo(output_index, &ti);
        if (status != NNFW_STATUS_NO_ERROR)
          return status;
 
        ti.dtype = NNFW_TYPE_TENSOR_FLOAT32;
 
        uint64_t output_size_in_bytes = getBufSize(&ti);
 
        status =
          set_output(output_index, ti.dtype, _output_buffers[output_index], output_size_in_bytes);
        if (status != NNFW_STATUS_NO_ERROR)
          return status;
      }
    }
 
    // Run quantized model
    if (!isStatePreparedOrFinishedRun())
    {
      std::cerr << "Error during nnfw_session::run_with_auto_compilation : "
                << "run should be run after prepare" << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    try
    {
      _execution->execute();
    }
    catch (const onert::InsufficientBufferSizeException &e)
    {
      // Currently insufficient buffer always means output buffer.
      std::cerr << "Error during nnfw_session::run_with_auto_compilation : " << e.what()
                << std::endl;
      return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
    }
    catch (const std::exception &e)
    {
      std::cerr << "Error during nnfw_session::run_with_auto_compilation : " << e.what()
                << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    _state = State::FINISHED_RUN;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References codegen(), nnfw_tensorinfo::dtype, input_size(), input_tensorinfo(), NNFW_STATUS_ERROR, NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_TYPE_TENSOR_FLOAT32, output_size(), output_tensorinfo(), prepare(), set_input(), set_output(), and onert::OnertException::what().

set_available_backends()

NNFW_STATUS nnfw_session::set_available_backends

(

const char *

backends

)

Definition at line 831 of file nnfw_session.cc.

{
  if (!isStateModelLoaded())
    return NNFW_STATUS_INVALID_STATE;
 
  try
  {
    if (!backends)
      return NNFW_STATUS_UNEXPECTED_NULL;
    if (null_terminating(backends, MAX_BACKEND_NAME_LENGTH) == false)
      return NNFW_STATUS_ERROR;
 
    using namespace onert::util;
 
    _coptions->backend_list = nnfw::misc::split(std::string{backends}, ';');
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_available_backends : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References MAX_BACKEND_NAME_LENGTH, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and nnfw::misc::split().

set_backends_per_operation()

NNFW_STATUS nnfw_session::set_backends_per_operation

(

const char *

backend_settings

)

Set backends with string-encoded mapping from operation index to backend type (cpu, acl_cl)

Definition at line 1100 of file nnfw_session.cc.

{
  if (backend_settings == NULL)
    return NNFW_STATUS_ERROR;
 
  if (!isStateModelLoaded())
    return NNFW_STATUS_INVALID_STATE;
 
  // Not supported multiple model
  // TODO Support this
  if (_nnpkg->model_count() > 1)
  {
    std::cerr << "Not supported multiple model" << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    // Backend for all
    auto &ms_options = _coptions->manual_scheduler_options;
    ms_options.setBackendMap(std::string{backend_settings});
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_backends_per_operation" << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_codegen_model_path()

NNFW_STATUS nnfw_session::set_codegen_model_path

(

const char *

path

)

Definition at line 1846 of file nnfw_session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      std::cerr << "invalid state" << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    assert(_codegen_manager != nullptr);
    _codegen_manager->exportModelPath(std::string(path));
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_codegen_model_path : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_config()

NNFW_STATUS nnfw_session::set_config	(	const char *	key,
		const char *	value
	)

Definition at line 876 of file nnfw_session.cc.

{
  if (!isStateModelLoaded())
    return NNFW_STATUS_INVALID_STATE;
 
  if (!key || !value)
    return NNFW_STATUS_UNEXPECTED_NULL;
 
  using namespace onert::util;
 
  const std::string skey = key;
 
  if (skey == config::GRAPH_DOT_DUMP)
  {
    _coptions->graph_dump_level = toInt(value);
  }
  else if (skey == config::EXECUTOR)
  {
    _coptions->executor = value;
  }
  else if (skey == config::OP_BACKEND_ALLOPS)
  {
    _coptions->manual_scheduler_options.backend_for_all = value;
  }
  else if (skey == config::USE_SCHEDULER)
  {
    _coptions->he_scheduler = toBool(value);
  }
  else if (skey == config::PROFILING_MODE)
  {
    _coptions->he_profiling_mode = toBool(value);
  }
  else
  {
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

set_execute_config()

NNFW_STATUS nnfw_session::set_execute_config	(	const NNFW_RUN_CONFIG	key,
		const char *	value
	)

Definition at line 1965 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::set_execution_config : Invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  switch (key)
  {
    case NNFW_RUN_CONFIG_DUMP_MINMAX:
      if (_coptions->workspace_dir.empty())
        return NNFW_STATUS_ERROR;
      _execution->executionOptions().dump_minmax = true;
      break;
    case NNFW_RUN_CONFIG_TRACE:
      if (_coptions->workspace_dir.empty())
        return NNFW_STATUS_ERROR;
      _execution->executionOptions().trace = true;
      break;
    case NNFW_RUN_CONFIG_PROFILE:
      _execution->executionOptions().profile = true;
      break;
    default:
      return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_RUN_CONFIG_DUMP_MINMAX, NNFW_RUN_CONFIG_PROFILE, NNFW_RUN_CONFIG_TRACE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_input()

NNFW_STATUS nnfw_session::set_input	(	uint32_t	index,
		NNFW_TYPE	type,
		const void *	buffer,
		size_t	length
	)

Definition at line 523 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::set_input : invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!buffer && length != 0)
  {
    std::cerr
      << "Error during nnfw_session::set_input : given buffer is NULL but the length is not 0"
      << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    // Allow float input internal quantization only
    if (type == NNFW_TYPE_TENSOR_FLOAT32)
      _execution->setInputType(onert::ir::IOIndex(index),
                               onert::ir::TypeInfo(onert::ir::DataType::FLOAT32));
    _execution->setInput(onert::ir::IOIndex(index), buffer, length);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_input : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_TYPE_TENSOR_FLOAT32.

Referenced by run_with_auto_compilation(), and package.infer.session::set_inputs().

set_input_layout()

NNFW_STATUS nnfw_session::set_input_layout	(	uint32_t	index,
		NNFW_LAYOUT	layout
	)

Definition at line 632 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::set_input_layout : "
              << "run should be run after prepare" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (layout != NNFW_LAYOUT_NONE && layout != NNFW_LAYOUT_CHANNELS_FIRST &&
        layout != NNFW_LAYOUT_CHANNELS_LAST)
    {
      std::cerr << "Error during nnfw_session::set_input_layout, not supported layout" << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    _execution->setInputLayout(onert::ir::IOIndex(index), convertLayout(layout));
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_input_layout : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_LAYOUT_CHANNELS_FIRST, NNFW_LAYOUT_CHANNELS_LAST, NNFW_LAYOUT_NONE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_input_tensorinfo()

NNFW_STATUS nnfw_session::set_input_tensorinfo	(	uint32_t	index,
		const nnfw_tensorinfo *	ti
	)

Definition at line 689 of file nnfw_session.cc.

{
  // sanity check
  {
    if (isStateInitialized())
    {
      std::cerr << "Error during set_input_tensorinfo : should be run after load_model"
                << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    if (ti == nullptr)
    {
      std::cerr << "Error during nnfw_session::set_input_tensorinfo : tensorinfo is null"
                << std::endl;
      return NNFW_STATUS_UNEXPECTED_NULL;
    }
 
    if (ti->rank <= 0 || ti->rank > NNFW_MAX_RANK)
    {
      std::cerr << "unsupported rank: " << ti->rank << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    for (int32_t i = 0; i < ti->rank; ++i)
    {
      if (ti->dims[i] <= 0)
      {
        std::cerr << "dim must be positive integer but was " << ti->dims[i] << std::endl;
        return NNFW_STATUS_ERROR;
      }
    }
  }
 
  onert::ir::Shape new_shape(ti->rank);
  for (int32_t i = 0; i < ti->rank; i++)
    new_shape.dim(i) = ti->dims[i];
 
  if (!isStatePreparedOrFinishedRun())
  {
 
    // In this case, if we apply input shape, it will propagate after compilation and excution
    _nnpkg->changeInputShape(index, new_shape);
  }
  else // when called after nnfw_session::prepare()
    _execution->changeInputShape(onert::ir::IOIndex(index), new_shape);
 
  return NNFW_STATUS_NO_ERROR;
}

References nnfw_tensorinfo::dims, NNFW_MAX_RANK, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and nnfw_tensorinfo::rank.

set_odc_param_minmax_records_count()

NNFW_STATUS nnfw_session::set_odc_param_minmax_records_count

(

int

minmax_records_count

)

Definition at line 2010 of file nnfw_session.cc.

{
  if (isStateInitialized() || isStateRunning())
  {
    std::cerr << "invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (_quant_manager->setMinMaxRecordsThreshold(minmax_records_count))
    return NNFW_STATUS_NO_ERROR;
  else
    return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_output()

NNFW_STATUS nnfw_session::set_output	(	uint32_t	index,
		NNFW_TYPE	type,
		void *	buffer,
		size_t	length
	)

Definition at line 556 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::set_output : invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!buffer && length != 0)
  {
    std::cerr
      << "Error during nnfw_session::set_output : given buffer is NULL but the length is not 0"
      << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    // Allow float output internal dequantization only
    if (type == NNFW_TYPE_TENSOR_FLOAT32)
      _execution->setOutputType(onert::ir::IOIndex(index),
                                onert::ir::TypeInfo(onert::ir::DataType::FLOAT32));
    _execution->setOutput(onert::ir::IOIndex(index), buffer, length);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_output : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_TYPE_TENSOR_FLOAT32.

Referenced by run_with_auto_compilation(), and package.infer.session::set_outputs().

set_output_layout()

NNFW_STATUS nnfw_session::set_output_layout	(	uint32_t	index,
		NNFW_LAYOUT	layout
	)

Definition at line 660 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    std::cerr << "Error during nnfw_session::set_output_layout : "
              << "run should be run after prepare" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (layout != NNFW_LAYOUT_NONE && layout != NNFW_LAYOUT_CHANNELS_FIRST &&
        layout != NNFW_LAYOUT_CHANNELS_LAST)
    {
      std::cerr << "Error during nnfw_session::set_output_layout, not supported layout"
                << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    _execution->setOutputLayout(onert::ir::IOIndex(index), convertLayout(layout));
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_output_layout : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_LAYOUT_CHANNELS_FIRST, NNFW_LAYOUT_CHANNELS_LAST, NNFW_LAYOUT_NONE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_prepare_config()

NNFW_STATUS nnfw_session::set_prepare_config	(	const NNFW_PREPARE_CONFIG	key,
		const char *	value
	)

Definition at line 1932 of file nnfw_session.cc.

{
  if (!isStateModelLoaded())
  {
    std::cerr << "Error during nnfw_session::set_prepare_config : Invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  switch (key)
  {
    case NNFW_PREPARE_CONFIG_PROFILE:
      _coptions->he_profiling_mode = true;
      break;
    default:
      return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_PREPARE_CONFIG_PROFILE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_quantization_type()

NNFW_STATUS nnfw_session::set_quantization_type

(

NNFW_QUANTIZE_TYPE

qtype

)

Definition at line 1760 of file nnfw_session.cc.

{
  using onert::odc::QuantizeType;
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      std::cerr << "invalid state" << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    QuantizeType odc_qtype = onert::odc::ODC_QTYPE_NOT_SET;
    switch (qtype)
    {
      case NNFW_QUANTIZE_TYPE_U8_ASYM:
        odc_qtype = onert::odc::ODC_QTYPE_U8_ASYM;
        break;
      case NNFW_QUANTIZE_TYPE_I16_SYM:
        odc_qtype = onert::odc::ODC_QTYPE_I16_SYM;
        break;
      case NNFW_QUANTIZE_TYPE_WO_I8_SYM:
        odc_qtype = onert::odc::ODC_QTYPE_WO_I8_SYM;
        break;
      case NNFW_QUANTIZE_TYPE_WO_I16_SYM:
        odc_qtype = onert::odc::ODC_QTYPE_WO_I16_SYM;
        break;
      default:
        return NNFW_STATUS_INVALID_STATE;
    }
    _quant_manager->quantizeType(odc_qtype);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_quantization_type : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_QUANTIZE_TYPE_I16_SYM, NNFW_QUANTIZE_TYPE_U8_ASYM, NNFW_QUANTIZE_TYPE_WO_I16_SYM, NNFW_QUANTIZE_TYPE_WO_I8_SYM, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, onert::odc::ODC_QTYPE_I16_SYM, onert::odc::ODC_QTYPE_NOT_SET, onert::odc::ODC_QTYPE_U8_ASYM, onert::odc::ODC_QTYPE_WO_I16_SYM, and onert::odc::ODC_QTYPE_WO_I8_SYM.

set_quantized_model_path()

NNFW_STATUS nnfw_session::set_quantized_model_path

(

const char *

path

)

Definition at line 1800 of file nnfw_session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      std::cerr << "invalid state" << std::endl;
      return NNFW_STATUS_INVALID_STATE;
    }
 
    _quant_manager->exportModelPath(std::string(path));
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::set_quantized_model_path : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_workspace()

NNFW_STATUS nnfw_session::set_workspace

(

const char *

dir

)

Definition at line 855 of file nnfw_session.cc.

{
  // TODO Check dir read & write permission
 
  if (!dir)
    return NNFW_STATUS_UNEXPECTED_NULL;
 
  if (!isStateInitialized())
    return NNFW_STATUS_INVALID_STATE;
 
  _coptions->workspace_dir = std::string(dir);
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

train_expected_tensorinfo() [1/2]

NNFW_STATUS nnfw_session::train_expected_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 1409 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedTraining())
  {
    std::cerr << "Error during nnfw_session::train_expected_tensorinfo : invalid state"
              << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Check index is valid: [0, getExpectedSize())
 
  // NYI
  (void)index;
  (void)ti;
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

train_expected_tensorinfo() [2/2]

NNFW_STATUS nnfw_session::train_expected_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

train_export_checkpoint() [1/2]

NNFW_STATUS nnfw_session::train_export_checkpoint

(

const char *

path

)

Definition at line 324 of file onert-micro.cpp.

{
  _train_interpreter->saveCheckpoint(_config, path);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR, and onert_micro::OMTrainingInterpreter::saveCheckpoint().

train_export_checkpoint() [2/2]

NNFW_STATUS nnfw_session::train_export_checkpoint

(

const char *

path

)

train_export_circle() [1/2]

NNFW_STATUS nnfw_session::train_export_circle

(

const char *

path

)

Definition at line 318 of file onert-micro.cpp.

{
  _train_interpreter->saveModel(_config, path);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR, and onert_micro::OMTrainingInterpreter::saveModel().

train_export_circle() [2/2]

NNFW_STATUS nnfw_session::train_export_circle

(

const char *

path

)

train_export_circleplus()

NNFW_STATUS nnfw_session::train_export_circleplus

(

const char *

path

)

Definition at line 1647 of file nnfw_session.cc.

{
  if (path == nullptr)
  {
    std::cerr << "Error during nnfw_session::train_export_circleplus : path is null" << std::endl;
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    std::cerr << "Error during nnfw_session::train_export_circleplus : invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    onert::exporter::CircleExporter exporter(_model_path.string(), std::string{path});
    exporter.updateWeight(_execution);
    exporter.updateMetadata(_train_info);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::train_export_circleplus : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, onert::exporter::CircleExporter::updateMetadata(), and onert::exporter::CircleExporter::updateWeight().

train_get_loss() [1/2]

NNFW_STATUS nnfw_session::train_get_loss	(	uint32_t	index,
		float *	loss
	)

Definition at line 370 of file onert-micro.cpp.

{
  onert_micro::OMMetrics m;
  switch (_config.training_context.loss)
  {
    case onert_micro::CROSS_ENTROPY:
      m = onert_micro::CROSS_ENTROPY_METRICS;
      break;
    default:
      m = onert_micro::CROSS_ENTROPY_METRICS;
      break;
  }
 
  _train_interpreter->evaluateMetric(_config, m, reinterpret_cast<void *>(loss),
                                     _config.training_context.batch_size);
  return NNFW_STATUS_NO_ERROR;
}

References onert_micro::OMTrainingContext::batch_size, onert_micro::CROSS_ENTROPY, onert_micro::CROSS_ENTROPY_METRICS, onert_micro::OMTrainingInterpreter::evaluateMetric(), onert_micro::OMTrainingContext::loss, m, NNFW_STATUS_NO_ERROR, and onert_micro::OMConfig::training_context.

train_get_loss() [2/2]

NNFW_STATUS nnfw_session::train_get_loss	(	uint32_t	index,
		float *	loss
	)

train_get_traininfo()

NNFW_STATUS nnfw_session::train_get_traininfo

(

nnfw_train_info *

info

)

Definition at line 1131 of file nnfw_session.cc.

{
  if (isStateInitialized())
  {
    // There is no _train_info in INITIALIZED, since _train_info is set when a model loaded
    std::cerr << "Error during nnfw_session::train_get_traininfo : invalid state";
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (info == nullptr)
  {
    std::cerr << "Error during nnfw_session::train_get_traininfo : info is nullptr" << std::endl;
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  // after model loaded, it ensures that _train_info is not nullptr
  assert(_train_info != nullptr);
 
  auto convertLossCode = [](const onert::ir::train::LossCode &code) -> NNFW_TRAIN_LOSS {
    switch (code)
    {
      case onert::ir::train::LossCode::Undefined:
        return NNFW_TRAIN_LOSS_UNDEFINED;
      case onert::ir::train::LossCode::MeanSquaredError:
        return NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR;
      case onert::ir::train::LossCode::CategoricalCrossentropy:
        return NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY;
      default:
        throw std::runtime_error{"fail to convert ir::train::LossCode"};
    }
  };
 
  auto convertLossReduction =
    [](const onert::ir::train::LossReductionType &type) -> NNFW_TRAIN_LOSS_REDUCTION {
    switch (type)
    {
      case onert::ir::train::LossReductionType::Undefined:
        return NNFW_TRAIN_LOSS_REDUCTION_UNDEFINED;
      case onert::ir::train::LossReductionType::SumOverBatchSize:
        return NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE;
      case onert::ir::train::LossReductionType::Sum:
        return NNFW_TRAIN_LOSS_REDUCTION_SUM;
      default:
        throw std::runtime_error{"fail to convert from ir::train::LossReductionType"};
        break;
    }
  };
 
  auto convertOptimizerCode =
    [](const onert::ir::train::OptimizerCode &code) -> NNFW_TRAIN_OPTIMIZER {
    switch (code)
    {
      case onert::ir::train::OptimizerCode::Undefined:
        return NNFW_TRAIN_OPTIMIZER_UNDEFINED;
      case onert::ir::train::OptimizerCode::SGD:
        return NNFW_TRAIN_OPTIMIZER_SGD;
      case onert::ir::train::OptimizerCode::Adam:
        return NNFW_TRAIN_OPTIMIZER_ADAM;
      default:
        throw std::runtime_error{"fail to convert from ir::train::OptimizerCode"};
    }
  };
 
  const auto &loss = _train_info->lossInfo();
  const auto &optim = _train_info->optimizerInfo();
 
  try
  {
    info->learning_rate = optim.learning_rate;
    info->batch_size = _train_info->batchSize();
    info->loss_info.loss = convertLossCode(loss.loss_code);
    info->loss_info.reduction_type = convertLossReduction(loss.reduction_type);
    info->opt = convertOptimizerCode(optim.optim_code);
 
    if (_train_info->getTrainableOps().size() > 0)
    {
      const uint32_t first_trainable_idx = _train_info->getTrainableOps().cbegin()->value();
      const uint32_t last_trainable_idx = _train_info->getTrainableOps().crbegin()->value();
      const uint32_t ops_size = primary_subgraph()->operations().size();
      const uint32_t trainable_indexes_range = last_trainable_idx - first_trainable_idx + 1;
 
      // check if trainable ops set contains continuous indexes on the back of the set
      if (last_trainable_idx == ops_size - 1 &&
          trainable_indexes_range == _train_info->getTrainableOps().size())
      {
        // check if all ops are trainable
        if (0 == first_trainable_idx)
        {
          info->num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_ALL;
        }
        else
        {
          info->num_of_trainable_ops = trainable_indexes_range;
        }
      }
      else
      {
        info->num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_INCORRECT_STATE;
        std::cerr << "conversion from set of trainable ops to num_of_trainable_ops is impossible"
                  << std::endl;
        return NNFW_STATUS_INVALID_STATE;
      }
    }
    else
    {
      // no layer will be trained
      info->num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_NONE;
    }
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::train_get_traininfo" << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References onert::ir::train::Adam, onert::ir::train::CategoricalCrossentropy, info, onert::ir::train::MeanSquaredError, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY, NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR, NNFW_TRAIN_LOSS_REDUCTION_SUM, NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE, NNFW_TRAIN_LOSS_REDUCTION_UNDEFINED, NNFW_TRAIN_LOSS_UNDEFINED, NNFW_TRAIN_OPTIMIZER_ADAM, NNFW_TRAIN_OPTIMIZER_SGD, NNFW_TRAIN_OPTIMIZER_UNDEFINED, NNFW_TRAIN_TRAINABLE_ALL, NNFW_TRAIN_TRAINABLE_INCORRECT_STATE, NNFW_TRAIN_TRAINABLE_NONE, onert::ir::IGraph::operations(), onert::ir::train::SGD, onert::util::ObjectManager< Index, Object >::size(), onert::ir::train::Sum, onert::ir::train::SumOverBatchSize, and onert::ir::train::Undefined.

train_import_checkpoint() [1/2]

NNFW_STATUS nnfw_session::train_import_checkpoint

(

const char *

path

)

Definition at line 330 of file onert-micro.cpp.

{
  _train_interpreter->loadCheckpoint(_config, path);
  return NNFW_STATUS_NO_ERROR;
}

References onert_micro::OMTrainingInterpreter::loadCheckpoint(), and NNFW_STATUS_NO_ERROR.

train_import_checkpoint() [2/2]

NNFW_STATUS nnfw_session::train_import_checkpoint

(

const char *

path

)

train_input_tensorinfo() [1/2]

NNFW_STATUS nnfw_session::train_input_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 1393 of file nnfw_session.cc.

{
  if (!isStatePreparedOrFinishedTraining())
  {
    std::cerr << "Error during nnfw_session::train_input_tensorinfo : invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Check index is valid: [0, getInputSize())
 
  // NYI
  (void)index;
  (void)ti;
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

train_input_tensorinfo() [2/2]

NNFW_STATUS nnfw_session::train_input_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

train_prepare() [1/2]

NNFW_STATUS nnfw_session::train_prepare

(

)

Definition at line 284 of file onert-micro.cpp.

{
  // TODO: Implement remaining jobs if inference_interpreter is introduced
  // maybe interpreter initialization ?
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR.

train_prepare() [2/2]

NNFW_STATUS nnfw_session::train_prepare

(

)

train_run() [1/2]

NNFW_STATUS nnfw_session::train_run

(

bool

update_weights

)

Definition at line 291 of file onert-micro.cpp.

{
  if (update_weights)
  {
    // TOOD: micro support update_weights ???
    // Here we use this flag for distinguish inference and train in trainaing interpreter
    _train_interpreter->trainSingleStep(_config);
    _config.training_context.num_epoch =
      _config.training_context.num_step / _config.training_context.batch_size + 1;
  }
  else
  {
    // TODO: support multiple input/output
    assert(outputbuf != nullptr);
    _train_interpreter->allocateInputs();
    float *allocated_input_data = (float *)_train_interpreter->getInputDataAt(0);
    float *user_input_data = (float *)_train_interpreter->getInputData(0);
    memcpy(allocated_input_data, user_input_data,
           sizeof(float) * _train_interpreter->getInputSizeAt(0));
    _train_interpreter->run(_config);
    float *calculated_ptr = (float *)_train_interpreter->getOutputDataAt(0);
    memcpy(outputbuf, calculated_ptr, sizeof(float) * _train_interpreter->getOutputSizeAt(0));
    _train_interpreter->reset();
  }
  return NNFW_STATUS_NO_ERROR;
}

References onert_micro::OMTrainingInterpreter::allocateInputs(), onert_micro::OMTrainingContext::batch_size, onert_micro::OMTrainingInterpreter::getInputData(), onert_micro::OMTrainingInterpreter::getInputDataAt(), onert_micro::OMTrainingInterpreter::getInputSizeAt(), onert_micro::OMTrainingInterpreter::getOutputDataAt(), onert_micro::OMTrainingInterpreter::getOutputSizeAt(), NNFW_STATUS_NO_ERROR, onert_micro::OMTrainingContext::num_epoch, onert_micro::OMTrainingContext::num_step, onert_micro::OMTrainingInterpreter::reset(), onert_micro::OMTrainingInterpreter::run(), onert_micro::OMConfig::training_context, and onert_micro::OMTrainingInterpreter::trainSingleStep().

train_run() [2/2]

NNFW_STATUS nnfw_session::train_run

(

bool

update_weights

)

train_set_expected() [1/2]

NNFW_STATUS nnfw_session::train_set_expected	(	uint32_t	index,
		const void *	expected,
		const nnfw_tensorinfo *	expected_tensorinfo
	)

Definition at line 1470 of file nnfw_session.cc.

{
  if (expected == nullptr)
  {
    std::cerr << "Error during nnfw_session::train_set_expected : expected buffer is null"
              << std::endl;
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    std::cerr << "Error during nnfw_session::train_set_expected : invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (index >= getOutputSize())
  {
    std::cerr << "Error during nnfw_session::train_set_expected : index is out of range"
              << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    auto output_ind = onert::ir::IOIndex(index);
    auto size = _execution->getOutputTotalSize(output_ind);
    if (expected_tensorinfo && getBufSize(expected_tensorinfo) != size)
    {
      std::cerr << "Error during nnfw_session::train_set_expected : invalid tensorinfo"
                << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    // NOTE Find the loss input index
    // Input is added as many as the number of outputs.
    // The loss index is calculated from the value obtained by subtracting the
    // total output(added loss input) from the total input size.
    auto input_index = getInputSize() - getOutputSize() + index;
    auto input_ind = onert::ir::IOIndex(input_index);
    _execution->setInput(input_ind, expected, size);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::train_set_expected : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and size.

train_set_expected() [2/2]

NNFW_STATUS nnfw_session::train_set_expected	(	uint32_t	index,
		void *	expected
	)

Definition at line 344 of file onert-micro.cpp.

{
  _train_interpreter->setTarget((uint8_t *)expected, index);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR, and onert_micro::OMTrainingInterpreter::setTarget().

train_set_input() [1/2]

NNFW_STATUS nnfw_session::train_set_input	(	uint32_t	index,
		const void *	input,
		const nnfw_tensorinfo *	input_tensorinfo
	)

Definition at line 1426 of file nnfw_session.cc.

{
  if (input == nullptr)
  {
    std::cerr << "Error during nnfw_session::train_set_input : input buffer is null" << std::endl;
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    std::cerr << "Error during nnfw_session::train_set_input : invalid state" << std::endl;
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (index >= getInputSize())
  {
    std::cerr << "Error during nnfw_session::train_set_input : index is out of range" << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    auto ind = onert::ir::IOIndex(index);
    auto size = _execution->getInputTotalSize(ind);
    if (input_tensorinfo && getBufSize(input_tensorinfo) != size)
    {
      std::cerr
        << "Error during nnfw_session::train_set_input : not supporeted to change tensorinfo"
        << std::endl;
      return NNFW_STATUS_ERROR;
    }
 
    _execution->setInput(ind, input, size);
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error during nnfw_session::train_set_input : " << e.what() << std::endl;
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References input_tensorinfo(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and size.

train_set_input() [2/2]

NNFW_STATUS nnfw_session::train_set_input	(	uint32_t	index,
		void *	input
	)

Definition at line 337 of file onert-micro.cpp.

{
  _train_interpreter->setInput((uint8_t *)input, index);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR, and onert_micro::OMTrainingInterpreter::setInput().

train_set_output() [1/2]

NNFW_STATUS nnfw_session::train_set_output	(	uint32_t	index,
		NNFW_TYPE	type,
		void *	buffer,
		size_t	length
	)

Definition at line 350 of file onert-micro.cpp.

{
  outputbuf = (uint8_t *)buffer;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR.

train_set_output() [2/2]

NNFW_STATUS nnfw_session::train_set_output	(	uint32_t	index,
		NNFW_TYPE	type,
		void *	buffer,
		size_t	length
	)

train_set_traininfo() [1/2]

NNFW_STATUS nnfw_session::train_set_traininfo

(

const nnfw_train_info *

info

)

Definition at line 357 of file onert-micro.cpp.

{
  _config.training_context.learning_rate = info->learning_rate;
  _config.training_context.batch_size = info->batch_size;
  _config.training_context.optimizer =
    (info->opt == NNFW_TRAIN_OPTIMIZER_ADAM) ? onert_micro::ADAM : onert_micro::SGD;
  _config.training_context.beta = info->adam_opt.beta;
  _config.training_context.beta_squares = info->adam_opt.beta2;
  _config.training_context.beta = info->adam_opt.epsilon;
  _config.training_context.num_of_train_layers = info->num_trainble_ops;
  return NNFW_STATUS_NO_ERROR;
}

References onert_micro::ADAM, onert_micro::OMTrainingContext::batch_size, onert_micro::OMTrainingContext::beta, onert_micro::OMTrainingContext::beta_squares, info, onert_micro::OMTrainingContext::learning_rate, NNFW_STATUS_NO_ERROR, NNFW_TRAIN_OPTIMIZER_ADAM, onert_micro::OMTrainingContext::num_of_train_layers, onert_micro::OMTrainingContext::optimizer, onert_micro::SGD, and onert_micro::OMConfig::training_context.

train_set_traininfo() [2/2]

NNFW_STATUS nnfw_session::train_set_traininfo

(

const nnfw_train_info *

info

)

---

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

• onert-micro/onert-micro/src/api/onert-micro.cpp
• runtime/onert/api/nnfw/src/nnfw_session.h
• runtime/onert/api/nnfw/src/nnfw_session.cc