Data Structures
class	NNFW_SESSION

struct	NnfwDeprecatedApiError

struct	NnfwError

struct	NnfwInsufficientOutputError

struct	NnfwInvalidStateError

struct	NnfwOutOfMemoryError

struct	NnfwUnexpectedNullError

struct	tensorinfo
	tensor info describes the type and shape of tensors More...

Functions
void	ensure_status (NNFW_STATUS status)
	Handle errors with NNFW_STATUS in API functions.

NNFW_LAYOUT	getLayout (const char *layout="")

NNFW_TYPE	getType (const char *type="")

const char *	getStringType (NNFW_TYPE type)

uint64_t	num_elems (const nnfw_tensorinfo *tensor_info)
	Get the total number of elements in nnfw_tensorinfo->dims.

py::list	get_dims (const tensorinfo &tensor_info)
	Get nnfw_tensorinfo->dims.

void	set_dims (tensorinfo &tensor_info, const py::list &array)
	Set nnfw_tensorinfo->dims.

void	bind_nnfw_exceptions (py::module_ &m)

void	bind_nnfw_session (pybind11::module_ &m)

void	bind_experimental_nnfw_session (pybind11::module_ &m)

void	bind_tensorinfo (pybind11::module_ &m)

void	bind_nnfw_enums (pybind11::module_ &m)

void	bind_nnfw_session (py::module_ &m)

void	bind_experimental_nnfw_session (py::module_ &m)

void	bind_tensorinfo (py::module_ &m)

void	bind_nnfw_enums (py::module_ &m)

Function Documentation

◆ bind_experimental_nnfw_session() [1/2]

void onert::api::python::bind_experimental_nnfw_session ( py::module_ & m )

Definition at line 153 of file nnfw_session_bindings.cc.

{
  // Add experimental APIs for the `NNFW_SESSION` class
  m.attr("nnfw_session")
    .cast<py::class_<NNFW_SESSION>>()
    .def("train_get_traininfo", &NNFW_SESSION::train_get_traininfo,
         "Retrieve training information for the model.")
    .def("train_set_traininfo", &NNFW_SESSION::train_set_traininfo, py::arg("info"),
         "Set training information for the model.")
    .def("train_prepare", &NNFW_SESSION::train_prepare, "Prepare for training")
    .def("train", &NNFW_SESSION::train, py::arg("update_weights") = true,
         "Run a training step, optionally updating weights.")
    .def("train_get_loss", &NNFW_SESSION::train_get_loss, py::arg("index"),
         "Retrieve the training loss for a specific index.")
    .def("train_set_input", &NNFW_SESSION::train_set_input<float>, py::arg("index"),
         py::arg("buffer"), "Set training input tensor for the given index (float).")
    .def("train_set_input", &NNFW_SESSION::train_set_input<int>, py::arg("index"),
         py::arg("buffer"), "Set training input tensor for the given index (int).")
    .def("train_set_input", &NNFW_SESSION::train_set_input<uint8_t>, py::arg("index"),
         py::arg("buffer"), "Set training input tensor for the given index (uint8).")
    .def("train_set_expected", &NNFW_SESSION::train_set_expected<float>, py::arg("index"),
         py::arg("buffer"), "Set expected output tensor for the given index (float).")
    .def("train_set_expected", &NNFW_SESSION::train_set_expected<int>, py::arg("index"),
         py::arg("buffer"), "Set expected output tensor for the given index (int).")
    .def("train_set_expected", &NNFW_SESSION::train_set_expected<uint8_t>, py::arg("index"),
         py::arg("buffer"), "Set expected output tensor for the given index (uint8).")
    .def("train_set_output", &NNFW_SESSION::train_set_output<float>, py::arg("index"),
         py::arg("buffer"), "Set output tensor for the given index (float).")
    .def("train_set_output", &NNFW_SESSION::train_set_output<int>, py::arg("index"),
         py::arg("buffer"), "Set output tensor for the given index (int).")
    .def("train_set_output", &NNFW_SESSION::train_set_output<uint8_t>, py::arg("index"),
         py::arg("buffer"), "Set output tensor for the given index (uint8).")
    .def("train_export_circle", &NNFW_SESSION::train_export_circle, py::arg("path"),

◆ bind_experimental_nnfw_session() [2/2]

void onert::api::python::bind_experimental_nnfw_session ( pybind11::module_ & m )

Referenced by PYBIND11_MODULE().

◆ bind_nnfw_enums() [1/2]

void onert::api::python::bind_nnfw_enums ( py::module_ & m )

Definition at line 40 of file nnfw_tensorinfo_bindings.cc.

{
  // Bind NNFW_TRAIN_LOSS
  py::enum_<NNFW_PREPARE_CONFIG>(m, "prepare_config", py::module_local())
    .value("PREPARE_CONFIG_PROFILE", NNFW_PREPARE_CONFIG_PROFILE)
    .value("ENABLE_INTERNAL_OUTPUT_ALLOC", NNFW_ENABLE_INTERNAL_OUTPUT_ALLOC);
}

References m, NNFW_ENABLE_INTERNAL_OUTPUT_ALLOC, and NNFW_PREPARE_CONFIG_PROFILE.

◆ bind_nnfw_enums() [2/2]

void onert::api::python::bind_nnfw_enums ( pybind11::module_ & m )

Referenced by PYBIND11_MODULE().

◆ bind_nnfw_exceptions()

void onert::api::python::bind_nnfw_exceptions ( py::module_ & m )

Definition at line 28 of file nnfw_exception_bindings.cc.

{
  // register base first
  py::register_exception<NnfwError>(m, "OnertError", PyExc_RuntimeError);
 
  // derived exceptions, each inheriting from NnfwError in Python as well
  py::register_exception<NnfwUnexpectedNullError>(m, "OnertUnexpectedNullError",
                                                  m.attr("OnertError").cast<py::object>());
  py::register_exception<NnfwInvalidStateError>(m, "OnertInvalidStateError",
                                                m.attr("OnertError").cast<py::object>());
  py::register_exception<NnfwOutOfMemoryError>(m, "OnertOutOfMemoryError",
                                               m.attr("OnertError").cast<py::object>());
  py::register_exception<NnfwInsufficientOutputError>(m, "OnertInsufficientOutputError",
                                                      m.attr("OnertError").cast<py::object>());
  py::register_exception<NnfwDeprecatedApiError>(m, "OnertDeprecatedApiError",
                                                 m.attr("OnertError").cast<py::object>());
}

References m.

Referenced by PYBIND11_MODULE().

◆ bind_nnfw_session() [1/2]

void onert::api::python::bind_nnfw_session ( py::module_ & m )

Definition at line 27 of file nnfw_session_bindings.cc.

{
  py::class_<NNFW_SESSION>(m, "nnfw_session", py::module_local())
    .def(
      py::init<const char *, const char *>(), py::arg("package_file_path"), py::arg("backends"),
      "Create a new session instance, load model from nnpackage file or directory, "
      "set available backends and prepare session to be ready for inference\n"
      "Parameters:\n"
      "\tpackage_file_path (str): Path to the nnpackage file or unzipped directory to be loaded\n"
      "\tbackends (str): Available backends on which nnfw uses\n"
      "\t\tMultiple backends can be set and they must be separated by a semicolon "
      "(ex: \"acl_cl;cpu\")\n"
      "\t\tAmong the multiple backends, the 1st element is used as the default backend.")
    .def("set_input_tensorinfo", &NNFW_SESSION::set_input_tensorinfo, py::arg("index"),
         py::arg("tensor_info"),
         "Set input model's tensor info for resizing.\n"
         "Parameters:\n"
         "\tindex (int): Index of input to be set (0-indexed)\n"
         "\ttensor_info (tensorinfo): Tensor info to be set")
    .def("prepare", &NNFW_SESSION::prepare, "Prepare for inference")
    .def("run", &NNFW_SESSION::run, "Run inference")
    .def("run_async", &NNFW_SESSION::run_async, "Run inference asynchronously")
    .def("wait", &NNFW_SESSION::wait, "Wait for asynchronous run to finish")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<float> &buffer) {
        session.set_input<float>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int> &buffer) {
        session.set_input<int>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<uint8_t> &buffer) {
        session.set_input<uint8_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<bool> &buffer) {
        session.set_input<bool>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int64_t> &buffer) {
        session.set_input<int64_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int8_t> &buffer) {
        session.set_input<int8_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def(
      "set_input",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int16_t> &buffer) {
        session.set_input<int16_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set input buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of input to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for input")
    .def("input_size", &NNFW_SESSION::input_size,
         "Get the number of inputs defined in loaded model\n"
         "Returns:\n"
         "\tint: The number of inputs")
    .def("output_size", &NNFW_SESSION::output_size,
         "Get the number of outputs defined in loaded model\n"
         "Returns:\n"
         "\tint: The number of outputs")
    .def("set_input_layout", &NNFW_SESSION::set_input_layout, py::arg("index"),
         py::arg("layout") = "NONE",
         "Set the layout of an input\n"
         "Parameters:\n"
         "\tindex (int): Index of input to be set (0-indexed)\n"
         "\tlayout (str): Layout to set to target input")
    .def("input_tensorinfo", &NNFW_SESSION::input_tensorinfo, py::arg("index"),
         "Get i-th input tensor info\n"
         "Parameters:\n"
         "\tindex (int): Index of input\n"
         "Returns:\n"
         "\ttensorinfo: Tensor info (shape, type, etc)")
    .def("output_tensorinfo", &NNFW_SESSION::output_tensorinfo, py::arg("index"),
         "Get i-th output tensor info\n"
         "Parameters:\n"
         "\tindex (int): Index of output\n"
         "Returns:\n"
         "\ttensorinfo: Tensor info (shape, type, etc)")
    .def("get_output", &NNFW_SESSION::get_output, py::arg("index"),
         R"pbdoc(
         Retrieve the internally-allocated dynamic output as a copy.
         Parameters:
             index (int): Index of the output tensor (0-indexed)

◆ bind_nnfw_session() [2/2]

void onert::api::python::bind_nnfw_session ( pybind11::module_ & m )

Referenced by PYBIND11_MODULE().

◆ bind_tensorinfo() [1/2]

void onert::api::python::bind_tensorinfo ( py::module_ & m )

Definition at line 27 of file nnfw_tensorinfo_bindings.cc.

{
  py::class_<tensorinfo>(m, "tensorinfo", "tensorinfo describes the type and shape of tensors",
                         py::module_local())
    .def(py::init<>(), "The constructor of tensorinfo")
    .def_readwrite("dtype", &tensorinfo::dtype, "The data type")
    .def_readwrite("rank", &tensorinfo::rank, "The number of dimensions (rank)")
    .def_property(
      "dims", [](const tensorinfo &ti) { return get_dims(ti); },
      [](tensorinfo &ti, const py::list &dims_list) { set_dims(ti, dims_list); },
      "The dimension of tensor. Maximum rank is 6 (NNFW_MAX_RANK).");
}

References onert::api::python::tensorinfo::dtype, get_dims(), m, onert::api::python::tensorinfo::rank, and set_dims().

◆ bind_tensorinfo() [2/2]

void onert::api::python::bind_tensorinfo ( pybind11::module_ & m )

Referenced by PYBIND11_MODULE().

◆ ensure_status()

void onert::api::python::ensure_status ( NNFW_STATUS status )

Handle errors with NNFW_STATUS in API functions.

This only handles NNFW_STATUS errors.

Parameters

[in] status The status returned by API functions

Definition at line 27 of file nnfw_api_wrapper.cc.

{
  switch (status)
  {
    case NNFW_STATUS::NNFW_STATUS_NO_ERROR:
      return;
    case NNFW_STATUS::NNFW_STATUS_ERROR:
      throw NnfwError("NNFW_STATUS_ERROR");
    case NNFW_STATUS::NNFW_STATUS_UNEXPECTED_NULL:
      throw NnfwUnexpectedNullError("NNFW_STATUS_UNEXPECTED_NULL");
    case NNFW_STATUS::NNFW_STATUS_INVALID_STATE:
      throw NnfwInvalidStateError("NNFW_STATUS_INVALID_STATE");
    case NNFW_STATUS::NNFW_STATUS_OUT_OF_MEMORY:
      throw NnfwOutOfMemoryError("NNFW_STATUS_OUT_OF_MEMORY");
    case NNFW_STATUS::NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE:
      throw NnfwInsufficientOutputError("NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE");
    case NNFW_STATUS::NNFW_STATUS_DEPRECATED_API:
      throw NnfwDeprecatedApiError("NNFW_STATUS_DEPRECATED_API");
    default:
      throw NnfwError("NNFW_UNKNOWN_ERROR");
  }
}

References NNFW_STATUS_DEPRECATED_API, NNFW_STATUS_ERROR, NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_OUT_OF_MEMORY, and NNFW_STATUS_UNEXPECTED_NULL.

◆ get_dims()

py::list onert::api::python::get_dims ( const tensorinfo & tensor_info )

Get nnfw_tensorinfo->dims.

This function is called to get dimension array of tensorinfo.

Parameters

[in] tensor_info Tensor info (shape, type, etc)

Returns: python list of dims

Definition at line 117 of file nnfw_api_wrapper.cc.

{
  py::list dims_list;
  for (int32_t i = 0; i < tensor_info.rank; ++i)
  {
    dims_list.append(tensor_info.dims[i]);
  }
  return dims_list;
}

References onert::api::python::tensorinfo::dims, and onert::api::python::tensorinfo::rank.

Referenced by bind_tensorinfo().

◆ getLayout()

NNFW_LAYOUT onert::api::python::getLayout ( const char * layout = "" )

Convert the layout with string to NNFW_LAYOUT

Parameters

[in] layout layout to be converted

Returns: proper layout if exists

Definition at line 50 of file nnfw_api_wrapper.cc.

{
  if (std::strcmp(layout, "NCHW") == 0)
    return NNFW_LAYOUT::NNFW_LAYOUT_CHANNELS_FIRST;
  else if (std::strcmp(layout, "NHWC") == 0)
    return NNFW_LAYOUT::NNFW_LAYOUT_CHANNELS_LAST;
  else if (std::strcmp(layout, "NONE") == 0)
    return NNFW_LAYOUT::NNFW_LAYOUT_NONE;
  else
    throw NnfwError(std::string("Unknown layout type: '") + layout + "'");
}

References NNFW_LAYOUT_CHANNELS_FIRST, NNFW_LAYOUT_CHANNELS_LAST, and NNFW_LAYOUT_NONE.

Referenced by onert::api::python::NNFW_SESSION::set_input_layout().

◆ getStringType()

const char * onert::api::python::getStringType ( NNFW_TYPE type )

Convert the type with NNFW_TYPE to string

Parameters

[in] type type to be converted

Returns: proper type

Definition at line 82 of file nnfw_api_wrapper.cc.

{
  switch (type)
  {
    case NNFW_TYPE::NNFW_TYPE_TENSOR_FLOAT32:
      return "float32";
    case NNFW_TYPE::NNFW_TYPE_TENSOR_INT32:
      return "int32";
    case NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM:
    case NNFW_TYPE::NNFW_TYPE_TENSOR_UINT8:
      return "uint8";
    case NNFW_TYPE::NNFW_TYPE_TENSOR_BOOL:
      return "bool";
    case NNFW_TYPE::NNFW_TYPE_TENSOR_INT64:
      return "int64";
    case NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM_SIGNED:
      return "int8";
    case NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT16_SYMM_SIGNED:
      return "int16";
    default:
      throw NnfwError(std::string("Cannot convert NNFW_TYPE enum to string (value=") +
                      std::to_string(static_cast<int>(type)) + ")");
  }
}

References NNFW_TYPE_TENSOR_FLOAT32, and NNFW_TYPE_TENSOR_INT32.

Referenced by onert::api::python::NNFW_SESSION::get_output(), onert::api::python::NNFW_SESSION::input_tensorinfo(), and onert::api::python::NNFW_SESSION::output_tensorinfo().

◆ getType()

NNFW_TYPE onert::api::python::getType ( const char * type = "" )

Convert the type with string to NNFW_TYPE

Parameters

[in] type type to be converted

Returns: proper type if exists

Definition at line 62 of file nnfw_api_wrapper.cc.

{
  if (std::strcmp(type, "float32") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_FLOAT32;
  else if (std::strcmp(type, "int32") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_INT32;
  else if (std::strcmp(type, "bool") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_UINT8;
  else if (std::strcmp(type, "bool") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_BOOL;
  else if (std::strcmp(type, "int64") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_INT64;
  else if (std::strcmp(type, "int8") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM_SIGNED;
  else if (std::strcmp(type, "int16") == 0)
    return NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT16_SYMM_SIGNED;
  else
    throw NnfwError(std::string("Cannot convert string to NNFW_TYPE: '") + type + "'");
}

References NNFW_TYPE_TENSOR_FLOAT32, and NNFW_TYPE_TENSOR_INT32.

Referenced by onert::api::python::NNFW_SESSION::set_input_tensorinfo().

◆ num_elems()

uint64_t onert::api::python::num_elems ( const nnfw_tensorinfo * tensor_info )

Get the total number of elements in nnfw_tensorinfo->dims.

This function is called to set the size of the input, output array.

Parameters

[in] tensor_info Tensor info (shape, type, etc)

Returns: total number of elements

Definition at line 107 of file nnfw_api_wrapper.cc.

{
  uint64_t n = 1;
  for (int32_t i = 0; i < tensor_info->rank; ++i)
  {
    n *= tensor_info->dims[i];
  }
  return n;
}

References nnfw_tensorinfo::dims, and nnfw_tensorinfo::rank.

Referenced by onert::api::python::NNFW_SESSION::set_input(), onert::api::python::NNFW_SESSION::set_output(), and onert::api::python::NNFW_SESSION::train_set_output().

◆ set_dims()

void onert::api::python::set_dims	(	tensorinfo &	tensor_info,
		const py::list &	array
	)

Set nnfw_tensorinfo->dims.

This function is called to set dimension array of tensorinfo.

Parameters

[in]	tensor_info	Tensor info (shape, type, etc)
[in]	array	array to set dimension

Definition at line 127 of file nnfw_api_wrapper.cc.

{
  tensor_info.rank = py::len(array);
  for (int32_t i = 0; i < tensor_info.rank; ++i)
  {
    tensor_info.dims[i] = py::cast<int32_t>(array[i]);
  }
}

References onert::api::python::tensorinfo::dims, and onert::api::python::tensorinfo::rank.

Referenced by bind_tensorinfo().

Data Structures

Functions

Function Documentation

◆ bind_experimental_nnfw_session() [1/2]

◆ bind_experimental_nnfw_session() [2/2]

◆ bind_nnfw_enums() [1/2]

◆ bind_nnfw_enums() [2/2]

◆ bind_nnfw_exceptions()

◆ bind_nnfw_session() [1/2]

◆ bind_nnfw_session() [2/2]

◆ bind_tensorinfo() [1/2]

◆ bind_tensorinfo() [2/2]

◆ ensure_status()

◆ get_dims()

◆ getLayout()

◆ getStringType()

◆ getType()

◆ num_elems()

◆ set_dims()