moco::onnx Namespace Reference

Data Structures
class	Constant_V1
	GraphBuilder for Constant(since version 1) node. More...
class	Constant_V9
	GraphBuilder for Constant(since version 9) node. More...
class	ConstantGraphBuilder
	GraphBuilder for Constant node. More...
class	Frontend
class	GraphBuilder
	Parent class of onnx operation graph builders. More...
class	GraphBuilderContext
	Class to store context to build IR from onnx. More...
class	GraphBuilderRegistry
	Class to return graph builder for passed onnx Operator. More...
class	Identity_V1
	GraphBuilder for Identity(since version 1) node. More...
class	IdentityGraphBuilder
	GraphBuilder for Identity node. More...
class	SymbolTable
	Class to store relations of Nodes and string names. More...

Functions
loco::DataType	as_loco_datatype (const int32_t tensor_dtype)
std::string	tensor_dtype_as_string (const int32_t tensor_dtype)
bool	is_default_domain (const std::string domain)
	If domain is empty string or onnx.ai, it is default domain.
std::vector< float >	get_float_data (const ::onnx::TensorProto &tensor)
	Get float tensor data.

Function Documentation

as_loco_datatype()

loco::DataType moco::onnx::as_loco_datatype

(

const int32_t

tensor_dtype

)

Definition at line 28 of file Convert.cpp.

{
  switch (tensor_dtype)
  {
    case 0: // UNDEFINED
      return loco::DataType::Unknown;
    case 1: // FLOAT
      return loco::DataType::FLOAT32;
    case 2: // UINT8
      return loco::DataType::U8;
    case 3: // INT8
      return loco::DataType::S8;
    case 4: // UINT16
      return loco::DataType::U16;
    case 5: // INT16
      return loco::DataType::S16;
    case 6: // INT32
      return loco::DataType::S32;
    case 7: // INT64
      return loco::DataType::S64;
    case 10: // FLOAT16
      return loco::DataType::FLOAT16;
    case 11: // DOUBLE
      return loco::DataType::FLOAT64;
    case 12: // UINT32
      return loco::DataType::U32;
    case 13: // UINT64
      return loco::DataType::U64;
 
    case 8:  // STRING
    case 9:  // BOOL
    case 14: // COMPLEX64
    case 15: // COMPLEX128
    case 16: // BFLOAT16
    default:
      break;
  }
  throw std::runtime_error{"Unsupported onnx dtype"};
}

Referenced by moco::onnx::Constant_V1::build(), and moco::onnx::Constant_V9::build().

get_float_data()

std::vector< float > moco::onnx::get_float_data

(

const ::onnx::TensorProto &

tensor

)

Get float tensor data.

Parameters

[in]

tensor

Tensor to get float data

Returns

Float vector which stores float tensor data

Definition at line 48 of file Onnxutil.cpp.

{
  std::vector<float> data;
 
  // Exactly one of the fields is used to store the elements of the tensor
  assert(!(tensor.has_raw_data() && (tensor.float_data_size() > 0)));
  assert(tensor.has_raw_data() || (tensor.float_data_size() > 0));
 
  if (tensor.has_raw_data())
  {
    const std::string raw_data = tensor.raw_data();
 
    // If platform is big endian, we should convert data as big endian
    if (!is_platform_little_endian())
    {
      // TODO Revise implementation of this logic. This is too complex.
      const char *little_endian_bytes = raw_data.c_str();
      char *big_endian_bytes = reinterpret_cast<char *>(std::malloc(raw_data.size()));
 
      for (int i = 0; i < raw_data.size(); ++i)
        big_endian_bytes[i] = little_endian_bytes[i];
 
      const size_t element_size = sizeof(float);
      const size_t num_elements = raw_data.size() / element_size;
      for (size_t i = 0; i < num_elements; ++i)
      {
        char *start_byte = big_endian_bytes + i * element_size;
        char *end_byte = start_byte + element_size - 1;
 
        for (size_t count = 0; count < element_size / 2; ++count)
        {
          char temp = *start_byte;
          *start_byte = *end_byte;
          *end_byte = temp;
          ++start_byte;
          --end_byte;
        }
      }
 
      data.insert(data.end(), reinterpret_cast<const float *>(big_endian_bytes),
                  reinterpret_cast<const float *>(big_endian_bytes + raw_data.size()));
 
      std::free(big_endian_bytes);
    }
    else
    {
      const char *bytes = raw_data.c_str();
      data.insert(data.end(), reinterpret_cast<const float *>(bytes),
                  reinterpret_cast<const float *>(bytes + raw_data.size()));
    }
  }
  else
  {
    for (int i = 0; i < tensor.float_data_size(); ++i)
      data.push_back(tensor.float_data(i));
  }
 
  return data;
}

is_default_domain()

bool moco::onnx::is_default_domain

(

const std::string

domain

)

If domain is empty string or onnx.ai, it is default domain.

Parameters

[in]

domain

The name of domain

Returns

Whether it is default domain or not

Definition at line 43 of file Onnxutil.cpp.

{
  return (domain.compare("") == 0 || domain.compare("onnx.ai") == 0);
}

tensor_dtype_as_string()

std::string moco::onnx::tensor_dtype_as_string

(

const int32_t

tensor_dtype

)

Definition at line 68 of file Convert.cpp.

{
  switch (tensor_dtype)
  {
    case 0: // UNDEFINED
      return "UNDEFINED";
    case 1: // FLOAT
      return "FLOAT";
    case 2: // UINT8
      return "UINT8";
    case 3: // INT8
      return "INT8";
    case 4: // UINT16
      return "UINT16";
    case 5: // INT16
      return "INT16";
    case 6: // INT32
      return "INT32";
    case 7: // INT64
      return "INT64";
    case 8: // STRING
      return "STRING";
    case 9: // BOOL
      return "BOOL";
    case 10: // FLOAT16
      return "FLOAT16";
    case 11: // DOUBLE
      return "DOUBLE";
    case 12: // UINT32
      return "UINT32";
    case 13: // UINT64
      return "UINT64";
    case 14: // COMPLEX64
      return "COMPLEX64";
    case 15: // COMPLEX128
      return "COMPLEX128";
    case 16: // BFLOAT16
      return "BFLOAT16";
    default:
      break;
  }
  throw std::runtime_error{"Unsupported onnx dtype"};
}

Referenced by moco::onnx::Constant_V1::validate().