nnfw_api_wrapper.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Samsung Electronics Co., Ltd. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include "nnfw_api_wrapper.h"
 
#include <iostream>
 
namespace onert::api::python
{
 
namespace py = pybind11;
 
void ensure_status(NNFW_STATUS status)
{
  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);
  }
}
void ensure_status(NNFW_STATUS status) {…}
 
NNFW_LAYOUT getLayout(const char *layout)
{
  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);
  }
}
NNFW_LAYOUT getLayout(const char *layout) {…}
 
NNFW_TYPE getType(const char *type)
{
  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);
  }
}
NNFW_TYPE getType(const char *type) {…}
 
const char *getStringType(NNFW_TYPE type)
{
  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);
  }
}
const char *getStringType(NNFW_TYPE type) {…}
 
uint64_t num_elems(const nnfw_tensorinfo *tensor_info)
{
  uint64_t n = 1;
  for (int32_t i = 0; i < tensor_info->rank; ++i)
  {
    n *= tensor_info->dims[i];
  }
  return n;
}
uint64_t num_elems(const nnfw_tensorinfo *tensor_info) {…}
 
py::list get_dims(const tensorinfo &tensor_info)
{
  py::list dims_list;
  for (int32_t i = 0; i < tensor_info.rank; ++i)
  {
    dims_list.append(tensor_info.dims[i]);
  }
  return dims_list;
}
py::list get_dims(const tensorinfo &tensor_info) {…}
 
void set_dims(tensorinfo &tensor_info, const py::list &array)
{
  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]);
  }
}
void set_dims(tensorinfo &tensor_info, const py::list &array) {…}
 
NNFW_SESSION::NNFW_SESSION(const char *package_file_path, const char *backends)
{
  this->session = nullptr;
  ensure_status(nnfw_create_session(&(this->session)));
  ensure_status(nnfw_load_model_from_file(this->session, package_file_path));
  ensure_status(nnfw_set_available_backends(this->session, backends));
}
NNFW_SESSION::NNFW_SESSION(const char *package_file_path, const char *backends) {…}
NNFW_SESSION::~NNFW_SESSION()
{
  if (session)
  {
    close_session();
  }
}
NNFW_SESSION::~NNFW_SESSION() {…}
 
void NNFW_SESSION::close_session()
{
  ensure_status(nnfw_close_session(this->session));
  this->session = nullptr;
}
void NNFW_SESSION::close_session() {…}
void NNFW_SESSION::set_input_tensorinfo(uint32_t index, const tensorinfo *tensor_info)
{
  nnfw_tensorinfo ti;
  ti.dtype = getType(tensor_info->dtype);
  ti.rank = tensor_info->rank;
  for (int i = 0; i < NNFW_MAX_RANK; i++)
  {
    ti.dims[i] = tensor_info->dims[i];
  }
  ensure_status(nnfw_set_input_tensorinfo(session, index, &ti));
}
void NNFW_SESSION::set_input_tensorinfo(uint32_t index, const tensorinfo *tensor_info) {…}
void NNFW_SESSION::prepare() { ensure_status(nnfw_prepare(session)); }
void NNFW_SESSION::run() { ensure_status(nnfw_run(session)); }
void NNFW_SESSION::run_async() { ensure_status(nnfw_run_async(session)); }
void NNFW_SESSION::wait() { ensure_status(nnfw_await(session)); }
uint32_t NNFW_SESSION::input_size()
{
  uint32_t number;
  NNFW_STATUS status = nnfw_input_size(session, &number);
  ensure_status(status);
  return number;
}
uint32_t NNFW_SESSION::input_size() {…}
uint32_t NNFW_SESSION::output_size()
{
  uint32_t number;
  NNFW_STATUS status = nnfw_output_size(session, &number);
  ensure_status(status);
  return number;
}
uint32_t NNFW_SESSION::output_size() {…}
void NNFW_SESSION::set_input_layout(uint32_t index, const char *layout)
{
  NNFW_LAYOUT nnfw_layout = getLayout(layout);
  ensure_status(nnfw_set_input_layout(session, index, nnfw_layout));
}
void NNFW_SESSION::set_input_layout(uint32_t index, const char *layout) {…}
void NNFW_SESSION::set_output_layout(uint32_t index, const char *layout)
{
  NNFW_LAYOUT nnfw_layout = getLayout(layout);
  ensure_status(nnfw_set_output_layout(session, index, nnfw_layout));
}
void NNFW_SESSION::set_output_layout(uint32_t index, const char *layout) {…}
tensorinfo NNFW_SESSION::input_tensorinfo(uint32_t index)
{
  nnfw_tensorinfo tensor_info = nnfw_tensorinfo();
  ensure_status(nnfw_input_tensorinfo(session, index, &tensor_info));
  tensorinfo ti;
  ti.dtype = getStringType(tensor_info.dtype);
  ti.rank = tensor_info.rank;
  for (int i = 0; i < NNFW_MAX_RANK; i++)
  {
    ti.dims[i] = tensor_info.dims[i];
  }
  return ti;
}
tensorinfo NNFW_SESSION::input_tensorinfo(uint32_t index) {…}
tensorinfo NNFW_SESSION::output_tensorinfo(uint32_t index)
{
  nnfw_tensorinfo tensor_info = nnfw_tensorinfo();
  ensure_status(nnfw_output_tensorinfo(session, index, &tensor_info));
  tensorinfo ti;
  ti.dtype = getStringType(tensor_info.dtype);
  ti.rank = tensor_info.rank;
  for (int i = 0; i < NNFW_MAX_RANK; i++)
  {
    ti.dims[i] = tensor_info.dims[i];
  }
  return ti;
}
tensorinfo NNFW_SESSION::output_tensorinfo(uint32_t index) {…}
 
// Experimental APIs for training
nnfw_train_info NNFW_SESSION::train_get_traininfo()
{
  nnfw_train_info train_info = nnfw_train_info();
  ensure_status(nnfw_train_get_traininfo(session, &train_info));
  return train_info;
}
nnfw_train_info NNFW_SESSION::train_get_traininfo() {…}
 
void NNFW_SESSION::train_set_traininfo(const nnfw_train_info *info)
{
  ensure_status(nnfw_train_set_traininfo(session, info));
}
void NNFW_SESSION::train_set_traininfo(const nnfw_train_info *info) {…}
 
void NNFW_SESSION::train_prepare() { ensure_status(nnfw_train_prepare(session)); }
 
void NNFW_SESSION::train(bool update_weights)
{
  ensure_status(nnfw_train(session, update_weights));
}
void NNFW_SESSION::train(bool update_weights) {…}
 
float NNFW_SESSION::train_get_loss(uint32_t index)
{
  float loss = 0.f;
  ensure_status(nnfw_train_get_loss(session, index, &loss));
  return loss;
}
float NNFW_SESSION::train_get_loss(uint32_t index) {…}
 
void NNFW_SESSION::train_export_circle(const py::str &path)
{
  const char *c_str_path = path.cast<std::string>().c_str();
  ensure_status(nnfw_train_export_circle(session, c_str_path));
}
void NNFW_SESSION::train_export_circle(const py::str &path) {…}
 
void NNFW_SESSION::train_import_checkpoint(const py::str &path)
{
  const char *c_str_path = path.cast<std::string>().c_str();
  ensure_status(nnfw_train_import_checkpoint(session, c_str_path));
}
void NNFW_SESSION::train_import_checkpoint(const py::str &path) {…}
 
void NNFW_SESSION::train_export_checkpoint(const py::str &path)
{
  const char *c_str_path = path.cast<std::string>().c_str();
  ensure_status(nnfw_train_export_checkpoint(session, c_str_path));
}
void NNFW_SESSION::train_export_checkpoint(const py::str &path) {…}
 
} // namespace onert::api::python