Data Structures
class	NNFW_SESSION

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_session (pybind11::module_ &m)

void	bind_experimental_nnfw_session (pybind11::module_ &m)

void	bind_tensorinfo (pybind11::module_ &m)

void	bind_nnfw_session (py::module_ &m)

void	bind_experimental_nnfw_session (py::module_ &m)

void	bind_tensorinfo (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 229 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"),
         "Export the trained model to a circle file.")
    .def("train_import_checkpoint", &NNFW_SESSION::train_import_checkpoint, py::arg("path"),
         "Import a training checkpoint from a file.")
    .def("train_export_checkpoint", &NNFW_SESSION::train_export_checkpoint, py::arg("path"),
         "Export the training checkpoint to a file.");
}

References m, onert::api::python::NNFW_SESSION::train(), onert::api::python::NNFW_SESSION::train_export_checkpoint(), onert::api::python::NNFW_SESSION::train_export_circle(), onert::api::python::NNFW_SESSION::train_get_loss(), onert::api::python::NNFW_SESSION::train_get_traininfo(), onert::api::python::NNFW_SESSION::train_import_checkpoint(), onert::api::python::NNFW_SESSION::train_prepare(), and onert::api::python::NNFW_SESSION::train_set_traininfo().

◆ bind_experimental_nnfw_session() [2/2]

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

Referenced by PYBIND11_MODULE().

◆ bind_nnfw_session() [1/2]

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

Definition at line 31 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(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<float> &buffer) {
        session.set_output<float>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .def(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int> &buffer) {
        session.set_output<int>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .def(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<uint8_t> &buffer) {
        session.set_output<uint8_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .def(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<bool> &buffer) {
        session.set_output<bool>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .def(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int64_t> &buffer) {
        session.set_output<int64_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .def(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int8_t> &buffer) {
        session.set_output<int8_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .def(
      "set_output",
      [](NNFW_SESSION &session, uint32_t index, py::array_t<int16_t> &buffer) {
        session.set_output<int16_t>(index, buffer);
      },
      py::arg("index"), py::arg("buffer"),
      "Set output buffer\n"
      "Parameters:\n"
      "\tindex (int): Index of output to be set (0-indexed)\n"
      "\tbuffer (numpy): Raw buffer for output")
    .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("set_output_layout", &NNFW_SESSION::set_output_layout, py::arg("index"),
         py::arg("layout") = "NONE",
         "Set the layout of an output\n"
         "Parameters:\n"
         "\tindex (int): Index of output to be set (0-indexed)\n"
         "\tlayout (str): Layout to set to target output")
    .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)");
}

◆ 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 31 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 30 of file nnfw_api_wrapper.cc.

{
  switch (status)
  {
    case NNFW_STATUS::NNFW_STATUS_NO_ERROR:
      break;
    case NNFW_STATUS::NNFW_STATUS_ERROR:
      std::cout << "[ERROR]\tNNFW_STATUS_ERROR\n";
      exit(1);
    case NNFW_STATUS::NNFW_STATUS_UNEXPECTED_NULL:
      std::cout << "[ERROR]\tNNFW_STATUS_UNEXPECTED_NULL\n";
      exit(1);
    case NNFW_STATUS::NNFW_STATUS_INVALID_STATE:
      std::cout << "[ERROR]\tNNFW_STATUS_INVALID_STATE\n";
      exit(1);
    case NNFW_STATUS::NNFW_STATUS_OUT_OF_MEMORY:
      std::cout << "[ERROR]\tNNFW_STATUS_OUT_OF_MEMORY\n";
      exit(1);
    case NNFW_STATUS::NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE:
      std::cout << "[ERROR]\tNNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE\n";
      exit(1);
    case NNFW_STATUS::NNFW_STATUS_DEPRECATED_API:
      std::cout << "[ERROR]\tNNFW_STATUS_DEPRECATED_API\n";
      exit(1);
  }
}

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 151 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 57 of file nnfw_api_wrapper.cc.

{
  if (!strcmp(layout, "NCHW"))
  {
    return NNFW_LAYOUT::NNFW_LAYOUT_CHANNELS_FIRST;
  }
  else if (!strcmp(layout, "NHWC"))
  {
    return NNFW_LAYOUT::NNFW_LAYOUT_CHANNELS_LAST;
  }
  else if (!strcmp(layout, "NONE"))
  {
    return NNFW_LAYOUT::NNFW_LAYOUT_NONE;
  }
  else
  {
    std::cout << "[ERROR]\tLAYOUT_TYPE\n";
    exit(1);
  }
}

References NNFW_LAYOUT_CHANNELS_FIRST, NNFW_LAYOUT_CHANNELS_LAST, and NNFW_LAYOUT_NONE.

Referenced by onert::api::python::NNFW_SESSION::set_input_layout(), and onert::api::python::NNFW_SESSION::set_output_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 116 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:
      std::cout << "[ERROR] NNFW_TYPE to String Failure\n";
      exit(1);
  }
}

References NNFW_TYPE_TENSOR_FLOAT32, and NNFW_TYPE_TENSOR_INT32.

Referenced by 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 78 of file nnfw_api_wrapper.cc.

{
  if (!strcmp(type, "float32"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_FLOAT32;
  }
  else if (!strcmp(type, "int32"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_INT32;
  }
  else if (!strcmp(type, "uint8"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_UINT8;
    // return NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM;
  }
  else if (!strcmp(type, "bool"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_BOOL;
  }
  else if (!strcmp(type, "int64"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_INT64;
  }
  else if (!strcmp(type, "int8"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM_SIGNED;
  }
  else if (!strcmp(type, "int16"))
  {
    return NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT16_SYMM_SIGNED;
  }
  else
  {
    std::cout << "[ERROR] String to NNFW_TYPE Failure\n";
    exit(1);
  }
}

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 141 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 161 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_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()