nnkit::support::tf::Runner Class Reference

#include <Runner.h>

Public Types
enum class	DataType {   Unknown , U8 , U16 , U32 ,   U64 , S8 , S16 , S32 ,   S64 , FLOAT }

Public Member Functions
	Runner (const char *pb_path)
	~Runner ()
bool	getTensorShapeFromGraphDef (const std::unique_ptr< ParsedTensor > &tensor, angkor::TensorShape &shape)
	Get tensor shape from GraphDef for input tensor only.
bool	getTensorDtypeFromGraphDef (const std::unique_ptr< ParsedTensor > &tensor, Runner::DataType &dtype)
	Get tensor data type from GraphDef.
void	prepareInputs (const std::vector< std::unique_ptr< ParsedTensor > > &inputs, TensorDataMap &data_map)
void	prepareOutputs (const std::vector< std::unique_ptr< ParsedTensor > > &outputs)
void	run ()
const std::vector< TF_Tensor * > &	output ()

Detailed Description

Definition at line 37 of file Runner.h.

Member Enumeration Documentation

DataType

enum class nnkit::support::tf::Runner::DataType

strong

Enumerator
Unknown
U8
U16
U32
U64
S8
S16
S32
S64
FLOAT

Definition at line 40 of file Runner.h.

  {
    Unknown, // Unknown type (serves as a default value)
 
    U8,  // 8-bit unsigned integer
    U16, // 16-bit unsigned integer
    U32, // 32-bit unsigned integer
    U64, // 64-bit unsigned integer
 
    S8,  // 8-bit signed integer
    S16, // 16-bit signed integer
    S32, // 32-bit signed integer
    S64, // 64-bit signed integer
 
    FLOAT, // floating-point
  };

Constructor & Destructor Documentation

Runner()

nnkit::support::tf::Runner::Runner

(

const char *

pb_path

)

Definition at line 125 of file Runner.cpp.

{
  // initialize member variables
  _sess = nullptr;
  _graph = TF_NewGraph();
  _status = TF_NewStatus();
 
  // import graph from file
  TF_Buffer *buffer = build_TFBuffer(pb_path);
  if (buffer == nullptr)
    throw std::runtime_error("Can't read buffer from file");
 
  TF_ImportGraphDefOptions *opts = TF_NewImportGraphDefOptions();
 
  TF_GraphImportGraphDef(_graph, buffer, opts, _status);
 
  TF_DeleteImportGraphDefOptions(opts);
  TF_DeleteBuffer(buffer);
 
  if (TF_GetCode(_status) != TF_OK) // TODO Consider wrapper to prevent memory leak
    throw std::runtime_error("Can't import GraphDef");
}

~Runner()

nnkit::support::tf::Runner::~Runner

(

)

Definition at line 148 of file Runner.cpp.

{
  if (_graph)
    TF_DeleteGraph(_graph);
 
  if (_sess)
  {
    TF_CloseSession(_sess, _status);
    TF_DeleteSession(_sess, _status);
  }
 
  for (auto tensor : _input_tensors)
    TF_DeleteTensor(tensor);
 
  for (auto tensor : _output_tensors)
    TF_DeleteTensor(tensor);
 
  TF_DeleteStatus(_status);
}

Member Function Documentation

getTensorDtypeFromGraphDef()

bool nnkit::support::tf::Runner::getTensorDtypeFromGraphDef	(	const std::unique_ptr< ParsedTensor > &	tensor,
		Runner::DataType &	dtype
	)

Get tensor data type from GraphDef.

Note

If the node cannot be found or dtype of the node is unknown, it returns false.

Definition at line 195 of file Runner.cpp.

{
  TF_Output tensor_op = {TF_GraphOperationByName(_graph, tensor->nodeName().c_str()),
                         tensor->tensorIndex()};
 
  if (tensor_op.oper == nullptr)
    return false;
 
  TF_DataType tf_dtype = TF_OperationOutputType(tensor_op);
 
  switch (tf_dtype)
  {
    case TF_DataType::TF_FLOAT:
      dtype = DataType::FLOAT;
      break;
    case TF_DataType::TF_UINT8:
      dtype = DataType::U8;
      break;
    case TF_DataType::TF_UINT16:
      dtype = DataType::U16;
      break;
    case TF_DataType::TF_UINT32:
      dtype = DataType::U32;
      break;
    case TF_DataType::TF_UINT64:
      dtype = DataType::U64;
      break;
    case TF_DataType::TF_INT8:
      dtype = DataType::S8;
      break;
    case TF_DataType::TF_INT16:
      dtype = DataType::S16;
      break;
    case TF_DataType::TF_INT32:
      dtype = DataType::S32;
      break;
    case TF_DataType::TF_INT64:
      dtype = DataType::S64;
      break;
    default:
      dtype = DataType::Unknown;
      return false;
  }
  return true;
}

getTensorShapeFromGraphDef()

bool nnkit::support::tf::Runner::getTensorShapeFromGraphDef	(	const std::unique_ptr< ParsedTensor > &	tensor,
		angkor::TensorShape &	shape
	)

Get tensor shape from GraphDef for input tensor only.

Note

If the node cannot be found or shape you provided is wrong or not enough though shape must be needed because of unknown shape in GraphDef, it returns false.

Definition at line 168 of file Runner.cpp.

{
  assert(!tensor->hasShape());
  TF_Output tensor_op = {TF_GraphOperationByName(_graph, tensor->nodeName().c_str()),
                         tensor->tensorIndex()};
 
  if (tensor_op.oper == nullptr)
    return false;
 
  int dim_size = TF_GraphGetTensorNumDims(_graph, tensor_op, _status);
  if (dim_size == -1)
    return false;
  int64_t dims[dim_size];
 
  TF_GraphGetTensorShape(_graph, tensor_op, dims, dim_size, _status);
 
  shape.resize(dim_size);
  for (int d = 0; d < dim_size; d++)
  {
    if (dims[d] == -1)
      return false;
    shape.dim(d) = dims[d];
  }
  return true;
}

References nncc::core::ADT::tensor::Shape::dim(), and nncc::core::ADT::tensor::Shape::resize().

Referenced by nnkit::support::tf::Backend::Backend().

output()

const std::vector< TF_Tensor * > & nnkit::support::tf::Runner::output ( )

inline

Definition at line 86 of file Runner.h.

{ return _output_tensors; }

Referenced by nnkit::support::tf::Backend::run().

prepareInputs()

void nnkit::support::tf::Runner::prepareInputs	(	const std::vector< std::unique_ptr< ParsedTensor > > &	inputs,
		TensorDataMap &	data_map
	)

Definition at line 242 of file Runner.cpp.

{
  assert(_graph);
 
  for (const auto &tensor : inputs)
  {
    TF_Output input_op = {TF_GraphOperationByName(_graph, tensor->nodeName().c_str()),
                          tensor->tensorIndex()};
 
    if (input_op.oper == nullptr)
      throw std::runtime_error("Can't init input_op : " + tensor->name());
 
    std::vector<int64_t> shape;
    for (int r = 0; r < tensor->shape().rank(); r++)
      shape.emplace_back(tensor->shape().dim(r));
 
    int size = 0;
    if (tensor->isFloatTensor())
      size = sizeof(float);
    else
      throw std::runtime_error("Not supported tensor type");
 
    TF_Tensor *input_tensor =
      create_tensor(TF_FLOAT, shape.data(), shape.size(), data_map.data(tensor.get()),
                    num_elements(tensor->shape()) * size);
 
    _input_ops.emplace_back(input_op);
    _input_tensors.emplace_back(input_tensor);
  }
}

References nnkit::support::tf::TensorDataMap::data(), size, and TF_FLOAT.

Referenced by nnkit::support::tf::Backend::prepare().

prepareOutputs()

void nnkit::support::tf::Runner::prepareOutputs

(

const std::vector< std::unique_ptr< ParsedTensor > > &

outputs

)

Definition at line 274 of file Runner.cpp.

{
  assert(_graph);
 
  for (const auto &tensor : outputs)
  {
    TF_Output output_op = {TF_GraphOperationByName(_graph, tensor->nodeName().c_str()),
                           tensor->tensorIndex()};
 
    if (output_op.oper == nullptr)
      throw std::runtime_error("Can't init output_op : " + tensor->name());
 
    _output_ops.emplace_back(output_op);
  }
 
  _output_tensors.resize(_output_ops.size());
}

Referenced by nnkit::support::tf::Backend::prepare().

run()

void nnkit::support::tf::Runner::run

(

)

Definition at line 292 of file Runner.cpp.

{
  assert(_graph);
  assert(_output_ops.size() > 0);
 
  TF_SessionOptions *options = TF_NewSessionOptions();
  _sess = TF_NewSession(_graph, options, _status);
  TF_DeleteSessionOptions(options);
 
  if (TF_GetCode(_status) != TF_OK)
    throw std::runtime_error(TF_Message(_status));
 
  TF_SessionRun(_sess,
                nullptr, // Run options.
                _input_ops.data(), _input_tensors.data(), _input_ops.size(), _output_ops.data(),
                _output_tensors.data(), _output_ops.size(), nullptr,
                0,       // Target operations, number of targets.
                nullptr, // Run metadata.
                _status  // Output status.
  );
 
  if (TF_GetCode(_status) != TF_OK)
    throw std::runtime_error(TF_Message(_status));
 
  TF_CloseSession(_sess, _status);
  TF_DeleteSession(_sess, _status);
  _sess = nullptr;
}

Referenced by nnkit::support::tf::Backend::run().

---

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

• compiler/nnkit-tf/support/include/nnkit/support/tf/Runner.h
• compiler/nnkit-tf/support/src/Runner.cpp