Namespace for tensorflow_cpp library. More...

Classes
class	Model
	Wrapper class for running TensorFlow SavedModels or FrozenGraphs. More...

Functions
tf::GraphDef	loadFrozenGraph (const std::string &file)
	Loads a TensorFlow graph from a frozen graph file.

bool	loadGraphIntoSession (tf::Session *session, const tf::GraphDef &graph_def)
	Loads a TensorFlow graph into an existing session.

tf::Session *	loadFrozenGraphIntoNewSession (const std::string &file, const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Loads a TensorFlow graph from a frozen graph file into a new session.

std::vector< std::string >	getGraphInputNames (const tf::GraphDef &graph_def)
	Determines the names of all graph input nodes.

std::vector< std::string >	getGraphOutputNames (const tf::GraphDef &graph_def)
	Determines the names of all graph output nodes.

std::vector< int >	getGraphNodeShape (const tf::GraphDef &graph_def, const std::string &node_name)
	Determines the shape of a given graph node.

tf::DataType	getGraphNodeType (const tf::GraphDef &graph_def, const std::string &node_name)
	Determines the datatype of a given graph node.

std::string	getGraphInfoString (const tf::GraphDef &graph_def)

tf::SavedModelBundleLite	loadSavedModel (const std::string &dir, const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Loads a TensorFlow SavedModel from a directory into a new session.

tf::Session *	loadSavedModelIntoNewSession (const std::string &dir, const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Loads a TensorFlow SavedModel from a directory into a new session.

tf::Session *	getSessionFromSavedModel (const tf::SavedModelBundleLite &saved_model)
	Returns the session that a SavedModel is loaded in.

std::string	getSavedModelNodeByLayerName (const tf::SavedModelBundleLite &saved_model, const std::string &layer_name, const std::string &signature="serving_default")
	Determines the node name from a SavedModel layer name.

std::string	getSavedModelLayerByNodeName (const tf::SavedModelBundleLite &saved_model, const std::string &node_name, const std::string &signature="serving_default")
	Determines the layer name from a SavedModel node name.

std::vector< std::string >	getSavedModelInputNames (const tf::SavedModelBundleLite &saved_model, const bool layer_names=false, const std::string &signature="serving_default")
	Determines the names of the SavedModel input nodes.

std::vector< std::string >	getSavedModelOutputNames (const tf::SavedModelBundleLite &saved_model, const bool layer_names=false, const std::string &signature="serving_default")
	Determines the names of the SavedModel output nodes.

std::vector< int >	getSavedModelNodeShape (const tf::SavedModelBundleLite &saved_model, const std::string &node_name, const std::string &signature="serving_default")
	Determines the shape of a given SavedModel node.

tf::DataType	getSavedModelNodeType (const tf::SavedModelBundleLite &saved_model, const std::string &node_name, const std::string &signature="serving_default")
	Determines the datatype of a given SavedModel node.

std::string	getSavedModelInfoString (const tf::SavedModelBundleLite &saved_model)

tf::SessionOptions	makeSessionOptions (const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Helps to quickly create SessionOptions.

tf::Session *	createSession (const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Creates a new TensorFlow session.

Detailed Description

Namespace for tensorflow_cpp library.

Function Documentation

◆ createSession()

tf::Session * tensorflow_cpp::createSession	(	const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Creates a new TensorFlow session.

Parameters

[in]	allow_growth	dynamically grow GPU usage
[in]	per_process_gpu_memory_fraction	maximum GPU memory fraction
[in]	visible_device_list	list of GPUs to use, e.g. "0,1"

Returns: tf::Session* session

Definition at line 78 of file utils.h.

                                             {
 
  tf::Session* session;
  tf::SessionOptions options = makeSessionOptions(
    allow_growth, per_process_gpu_memory_fraction, visible_device_list);
  tf::Status status = tf::NewSession(options, &session);
  if (!status.ok())
    throw std::runtime_error("Failed to create new session: " +
                             status.ToString());
 
  return session;
}

◆ getGraphInfoString()

std::string tensorflow_cpp::getGraphInfoString ( const tf::GraphDef & graph_def )

inline

Returns information about a FrozenGraph model.

Returns a formatted message containing information about the shape and type of all inputs/outputs of a FrozenGraph.

Currently limited to single-output graphs.

Parameters

[in] graph_def graph

Returns: std::string formatted info message

Definition at line 221 of file graph_utils.h.

                                                                 {
 
  std::stringstream ss;
  ss << "FrozenGraph Info:" << std::endl;
 
  const std::vector<std::string> inputs = getGraphInputNames(graph_def);
  const std::vector<std::string> outputs = getGraphOutputNames(graph_def);
 
  ss << "Inputs: " << inputs.size() << std::endl;
  for (const auto& name : inputs) {
    const auto& shape = getGraphNodeShape(graph_def, name);
    const auto& dtype = getGraphNodeType(graph_def, name);
    ss << "  " << name << std::endl;
    ss << "    Shape: [ ";
    for (int d = 0; d < shape.size(); d++) {
      ss << shape[d] << ", ";
    }
    ss << "]" << std::endl;
    ss << "    DataType: " << tf::DataTypeString(dtype) << std::endl;
  }
 
  ss << "Outputs: " << outputs.size() << std::endl;
  for (const auto& name : outputs) {
    const auto& shape = getGraphNodeShape(graph_def, name);
    const auto& dtype = getGraphNodeType(graph_def, name);
    ss << "  " << name << std::endl;
    ss << "    Shape: [ ";
    for (int d = 0; d < shape.size(); d++) {
      ss << shape[d] << ", ";
    }
    ss << "]" << std::endl;
    ss << "    DataType: " << tf::DataTypeString(dtype) << std::endl;
  }
 
  return ss.str();
}

◆ getGraphInputNames()

std::vector< std::string > tensorflow_cpp::getGraphInputNames ( const tf::GraphDef & graph_def )

inline

Determines the names of all graph input nodes.

Parameters

[in] graph_def graph

Returns: std::vector<std::string> list of input node names

Definition at line 118 of file graph_utils.h.

                               {
 
  std::vector<std::string> input_nodes;
  for (const tf::NodeDef& node : graph_def.node()) {
    if (node.op() == "Placeholder") input_nodes.push_back(node.name());
  }
 
  return input_nodes;
}

◆ getGraphNodeShape()

std::vector< int > tensorflow_cpp::getGraphNodeShape	(	const tf::GraphDef &	graph_def,
		const std::string &	node_name )

inline

Determines the shape of a given graph node.

Parameters

[in]	graph_def	graph
[in]	node_name	node name

Returns: std::vector<int> node shape

Definition at line 168 of file graph_utils.h.

                                                                      {
 
  std::vector<int> node_shape;
  for (const tf::NodeDef& node : graph_def.node()) {
    if (node.name() == node_name) {
      if (node.attr().count("shape") == 0) return node_shape;
      auto shape = node.attr().at("shape").shape();
      for (int d = 0; d < shape.dim_size(); d++)
        node_shape.push_back(shape.dim(d).size());
      break;
    }
  }
 
  return node_shape;
}

◆ getGraphNodeType()

tf::DataType tensorflow_cpp::getGraphNodeType	(	const tf::GraphDef &	graph_def,
		const std::string &	node_name )

inline

Determines the datatype of a given graph node.

Parameters

[in]	graph_def	graph
[in]	node_name	node name

Returns: tf::DataType node datatype

Definition at line 194 of file graph_utils.h.

                                                                 {
 
  tf::DataType type = tf::DT_INVALID;
  for (const tf::NodeDef& node : graph_def.node()) {
    if (node.name() == node_name) {
      if (node.attr().count("dtype") == 0) return type;
      type = node.attr().at("dtype").type();
      break;
    }
  }
  return type;
}

◆ getGraphOutputNames()

std::vector< std::string > tensorflow_cpp::getGraphOutputNames ( const tf::GraphDef & graph_def )

inline

Determines the names of all graph output nodes.

Parameters

[in] graph_def graph

Returns: std::vector<std::string> list of output node names

Definition at line 137 of file graph_utils.h.

                               {
 
  std::vector<std::string> output_nodes;
  std::vector<std::string> nodes_with_outputs;
  std::unordered_set<std::string> unlikely_output_ops = {"Const", "Assign",
                                                         "NoOp", "Placeholder",
                                                         "Assert"};
  for (const tf::NodeDef& node : graph_def.node()) {
    for (const std::string& input_name : node.input())
      nodes_with_outputs.push_back(input_name);
  }
  for (const tf::NodeDef& node : graph_def.node()) {
    if (std::find(nodes_with_outputs.begin(), nodes_with_outputs.end(),
                  node.name()) == nodes_with_outputs.end() &&
        unlikely_output_ops.count(node.op()) == 0)
      output_nodes.push_back(node.name());
  }
 
  return output_nodes;
}

◆ getSavedModelInfoString()

std::string tensorflow_cpp::getSavedModelInfoString ( const tf::SavedModelBundleLite & saved_model )

inline

Returns information about a SavedModel model.

Returns a formatted message containing information about the shape and type of all inputs/outputs of all SavedModel signatures.

Parameters

[in] saved_model SavedModel

Returns: std::string formatted info message

Definition at line 340 of file saved_model_utils.h.

                                             {
 
  std::stringstream ss;
  ss << "SavedModel Info:" << std::endl;
 
  ss << "Signatures:" << std::endl;
  const auto& signatures = saved_model.GetSignatures();
  for (const auto& sig : signatures) {
 
    ss << "  " << sig.first << std::endl;
    const auto& def = sig.second;
 
    ss << "    Inputs: " << def.inputs_size() << std::endl;
    for (const auto& node : def.inputs()) {
      ss << "      " << node.first << ": " << node.second.name() << std::endl;
      ss << "        Shape: [ ";
      for (int d = 0; d < node.second.tensor_shape().dim_size(); d++) {
        ss << node.second.tensor_shape().dim(d).size() << ", ";
      }
      ss << "]" << std::endl;
      ss << "        DataType: " << tf::DataTypeString(node.second.dtype())
         << std::endl;
    }
 
    ss << "    Outputs: " << def.outputs_size() << std::endl;
    for (const auto& node : def.outputs()) {
      ss << "      " << node.first << ": " << node.second.name() << std::endl;
      ss << "        Shape: [ ";
      for (int d = 0; d < node.second.tensor_shape().dim_size(); d++) {
        ss << node.second.tensor_shape().dim(d).size() << ", ";
      }
      ss << "]" << std::endl;
      ss << "        DataType: " << tf::DataTypeString(node.second.dtype())
         << std::endl;
    }
  }
 
  return ss.str();
}

◆ getSavedModelInputNames()

std::vector< std::string > tensorflow_cpp::getSavedModelInputNames	(	const tf::SavedModelBundleLite &	saved_model,
		const bool	layer_names = false,
		const std::string &	signature = "serving_default" )

inline

Determines the names of the SavedModel input nodes.

These are the names that need to be passed to session->Run. Alternatively, using layer_names, the layer names can be returned.

Returned names are sorted alphabetically, since their order is not deterministic in general. The sorting is always based on the actual node names, even when returning layer names.

Parameters

[in]	saved_model	SavedModel
[in]	layer_names	whether to return layer names
[in]	signature	SavedModel signature to query

Returns: std::vector<std::string> input names

Definition at line 198 of file saved_model_utils.h.

                                                  {
 
  std::vector<std::string> names;
  const tf::SignatureDef& model_def = saved_model.GetSignatures().at(signature);
  for (const auto& node : model_def.inputs()) {
    const std::string& key = node.first;
    const tf::TensorInfo& info = node.second;
    names.push_back(info.name());
  }
  std::sort(names.begin(), names.end());
 
  if (layer_names) {
    std::vector<std::string> node_names = names;
    names = {};
    for (const auto& node_name : node_names)
      names.push_back(
        getSavedModelLayerByNodeName(saved_model, node_name, signature));
  }
 
  return names;
}

◆ getSavedModelLayerByNodeName()

std::string tensorflow_cpp::getSavedModelLayerByNodeName	(	const tf::SavedModelBundleLite &	saved_model,
		const std::string &	node_name,
		const std::string &	signature = "serving_default" )

inline

Determines the layer name from a SavedModel node name.

Layer names are specified during model construction, node names must be passed to session->Run.

Parameters

[in]	saved_model	SavedModel
[in]	node_name	node name
[in]	signature	SavedModel signature to query

Returns: std::string layer name

Definition at line 159 of file saved_model_utils.h.

                                                  {
 
  std::string layer_name;
  const tf::SignatureDef& model_def = saved_model.GetSignatures().at(signature);
  auto inputs = model_def.inputs();
  auto outputs = model_def.outputs();
  auto& nodes = inputs;
  nodes.insert(outputs.begin(), outputs.end());
  for (const auto& node : nodes) {
    const std::string& key = node.first;
    const tf::TensorInfo& info = node.second;
    if (info.name() == node_name) {
      layer_name = key;
      break;
    }
  }
 
  return layer_name;
}

◆ getSavedModelNodeByLayerName()

std::string tensorflow_cpp::getSavedModelNodeByLayerName	(	const tf::SavedModelBundleLite &	saved_model,
		const std::string &	layer_name,
		const std::string &	signature = "serving_default" )

inline

Determines the node name from a SavedModel layer name.

Layer names are specified during model construction, node names must be passed to session->Run.

Parameters

[in]	saved_model	SavedModel
[in]	layer_name	layer name
[in]	signature	SavedModel signature to query

Returns: std::string node name

Definition at line 124 of file saved_model_utils.h.

                                                  {
 
  std::string node_name;
  const tf::SignatureDef& model_def = saved_model.GetSignatures().at(signature);
  auto inputs = model_def.inputs();
  auto outputs = model_def.outputs();
  auto& nodes = inputs;
  nodes.insert(outputs.begin(), outputs.end());
  for (const auto& node : nodes) {
    const std::string& key = node.first;
    const tf::TensorInfo& info = node.second;
    if (key == layer_name) {
      node_name = info.name();
      break;
    }
  }
 
  return node_name;
}

◆ getSavedModelNodeShape()

std::vector< int > tensorflow_cpp::getSavedModelNodeShape	(	const tf::SavedModelBundleLite &	saved_model,
		const std::string &	node_name,
		const std::string &	signature = "serving_default" )

inline

Determines the shape of a given SavedModel node.

Parameters

[in]	saved_model	SavedModel
[in]	node_name	node name
[in]	signature	SavedModel signature to query

Returns: std::vector<int> node shape

Definition at line 273 of file saved_model_utils.h.

                                                  {
 
  std::vector<int> node_shape;
  const tf::SignatureDef& model_def = saved_model.GetSignatures().at(signature);
  auto inputs = model_def.inputs();
  auto outputs = model_def.outputs();
  auto& nodes = inputs;
  nodes.insert(outputs.begin(), outputs.end());
  for (const auto& node : nodes) {
    const std::string& key = node.first;
    const tf::TensorInfo& info = node.second;
    if (info.name() == node_name) {
      const auto& shape = info.tensor_shape();
      for (int d = 0; d < shape.dim_size(); d++)
        node_shape.push_back(shape.dim(d).size());
      break;
    }
  }
 
  return node_shape;
}

◆ getSavedModelNodeType()

tf::DataType tensorflow_cpp::getSavedModelNodeType	(	const tf::SavedModelBundleLite &	saved_model,
		const std::string &	node_name,
		const std::string &	signature = "serving_default" )

inline

Determines the datatype of a given SavedModel node.

Parameters

[in]	saved_model	SavedModel
[in]	node_name	node name
[in]	signature	SavedModel signature to query

Returns: tf::DataType node datatype

Definition at line 307 of file saved_model_utils.h.

                                                  {
 
  tf::DataType type = tf::DT_INVALID;
  const tf::SignatureDef& model_def = saved_model.GetSignatures().at(signature);
  auto inputs = model_def.inputs();
  auto outputs = model_def.outputs();
  auto& nodes = inputs;
  nodes.insert(outputs.begin(), outputs.end());
  for (const auto& node : nodes) {
    const std::string& key = node.first;
    const tf::TensorInfo& info = node.second;
    if (info.name() == node_name) {
      type = info.dtype();
      break;
    }
  }
 
  return type;
}

◆ getSavedModelOutputNames()

std::vector< std::string > tensorflow_cpp::getSavedModelOutputNames	(	const tf::SavedModelBundleLite &	saved_model,
		const bool	layer_names = false,
		const std::string &	signature = "serving_default" )

inline

Determines the names of the SavedModel output nodes.

These are the names that need to be passed to session->Run. Alternatively, using layer_names, the layer names can be returned.

Returned names are sorted alphabetically, since their order is not deterministic in general. The sorting is always based on the actual node names, even when returning layer names.

Parameters

[in]	saved_model	SavedModel
[in]	layer_names	whether to return layer names
[in]	signature	SavedModel signature to query

Returns: std::vector<std::string> output names

Definition at line 239 of file saved_model_utils.h.

                                                  {
 
  std::vector<std::string> names;
  const tf::SignatureDef& model_def = saved_model.GetSignatures().at(signature);
  for (const auto& node : model_def.outputs()) {
    const std::string& key = node.first;
    const tf::TensorInfo& info = node.second;
    names.push_back(info.name());
  }
  std::sort(names.begin(), names.end());
 
  if (layer_names) {
    std::vector<std::string> node_names = names;
    names = {};
    for (const auto& node_name : node_names)
      names.push_back(
        getSavedModelLayerByNodeName(saved_model, node_name, signature));
  }
 
  return names;
}

◆ getSessionFromSavedModel()

tf::Session * tensorflow_cpp::getSessionFromSavedModel ( const tf::SavedModelBundleLite & saved_model )

inline

Returns the session that a SavedModel is loaded in.

Parameters

[in] saved_model SavedModel

Returns: tf::Session* session

Definition at line 105 of file saved_model_utils.h.

                                             {
 
  return saved_model.GetSession();
}

◆ loadFrozenGraph()

tf::GraphDef tensorflow_cpp::loadFrozenGraph ( const std::string & file )

inline

Loads a TensorFlow graph from a frozen graph file.

Parameters

[in] file frozen graph file

Returns: tf::GraphDef graph

Definition at line 53 of file graph_utils.h.

                                                         {
 
  tf::GraphDef graph_def;
  tf::Status status = tf::ReadBinaryProto(tf::Env::Default(), file, &graph_def);
  if (!status.ok())
    throw std::runtime_error("Failed to load frozen graph: " +
                             status.ToString());
 
  return graph_def;
}

◆ loadFrozenGraphIntoNewSession()

tf::Session * tensorflow_cpp::loadFrozenGraphIntoNewSession	(	const std::string &	file,
		const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Loads a TensorFlow graph from a frozen graph file into a new session.

Parameters

[in]	file	frozen graph file
[in]	allow_growth	dynamically grow GPU usage
[in]	per_process_gpu_memory_fraction	maximum GPU memory fraction
[in]	visible_device_list	list of GPUs to use, e.g. "0,1"

Returns: tf::Session* session

Definition at line 97 of file graph_utils.h.

                                             {
 
  tf::GraphDef graph_def = loadFrozenGraph(file);
  tf::Session* session = createSession(
    allow_growth, per_process_gpu_memory_fraction, visible_device_list);
  if (!loadGraphIntoSession(session, graph_def)) return nullptr;
 
  return session;
}

◆ loadGraphIntoSession()

bool tensorflow_cpp::loadGraphIntoSession	(	tf::Session *	session,
		const tf::GraphDef &	graph_def )

inline

Loads a TensorFlow graph into an existing session.

Parameters

[in]	session	session
[in]	graph_def	graph

Returns: true if operation succeeded; false if operation failed

Definition at line 74 of file graph_utils.h.

                                                              {
 
  tf::Status status = session->Create(graph_def);
  if (!status.ok())
    throw std::runtime_error("Failed to load graph into session: " +
                             status.ToString());
 
  return true;
}

◆ loadSavedModel()

tf::SavedModelBundleLite tensorflow_cpp::loadSavedModel	(	const std::string &	dir,
		const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Loads a TensorFlow SavedModel from a directory into a new session.

Parameters

[in]	dir	SavedModel directory
[in]	allow_growth	dynamically grow GPU usage
[in]	per_process_gpu_memory_fraction	maximum GPU memory fraction
[in]	visible_device_list	list of GPUs to use, e.g. "0,1"

Returns: tf::SavedModelBundleLite SavedModel

Definition at line 57 of file saved_model_utils.h.

                                             {
 
  tf::SavedModelBundleLite saved_model;
  tf::SessionOptions session_options = makeSessionOptions(
    allow_growth, per_process_gpu_memory_fraction, visible_device_list);
  tf::Status status =
    tf::LoadSavedModel(session_options, tf::RunOptions(), dir,
                       {tf::kSavedModelTagServe}, &saved_model);
  if (!status.ok())
    throw std::runtime_error("Failed to load SavedModel: " + status.ToString());
 
  return saved_model;
}

◆ loadSavedModelIntoNewSession()

tf::Session * tensorflow_cpp::loadSavedModelIntoNewSession	(	const std::string &	dir,
		const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Loads a TensorFlow SavedModel from a directory into a new session.

Parameters

[in]	dir	SavedModel directory
[in]	allow_growth	dynamically grow GPU usage
[in]	per_process_gpu_memory_fraction	maximum GPU memory fraction
[in]	visible_device_list	list of GPUs to use, e.g. "0,1"

Returns: tf::Session* session

Definition at line 85 of file saved_model_utils.h.

                                             {
 
  tf::SavedModelBundleLite saved_model = loadSavedModel(
    dir, allow_growth, per_process_gpu_memory_fraction, visible_device_list);
  tf::Session* session = saved_model.GetSession();
 
  return session;
}

◆ makeSessionOptions()

tf::SessionOptions tensorflow_cpp::makeSessionOptions	(	const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Helps to quickly create SessionOptions.

Parameters

[in]	allow_growth	dynamically grow GPU usage
[in]	per_process_gpu_memory_fraction	maximum GPU memory fraction
[in]	visible_device_list	list of GPUs to use, e.g. "0,1"

Returns: tf::SessionOptions session options

Definition at line 52 of file utils.h.

                                             {
 
  tf::SessionOptions options = tf::SessionOptions();
  tf::ConfigProto* config = &options.config;
  tf::GPUOptions* gpu_options = config->mutable_gpu_options();
  gpu_options->set_allow_growth(allow_growth);
  gpu_options->set_per_process_gpu_memory_fraction(
    per_process_gpu_memory_fraction);
  gpu_options->set_visible_device_list(visible_device_list);
 
  return options;
}

Classes

Functions

Detailed Description

Function Documentation

◆ createSession()

◆ getGraphInfoString()

◆ getGraphInputNames()

◆ getGraphNodeShape()

◆ getGraphNodeType()

◆ getGraphOutputNames()

◆ getSavedModelInfoString()

◆ getSavedModelInputNames()

◆ getSavedModelLayerByNodeName()

◆ getSavedModelNodeByLayerName()

◆ getSavedModelNodeShape()

◆ getSavedModelNodeType()

◆ getSavedModelOutputNames()

◆ getSessionFromSavedModel()

◆ loadFrozenGraph()

◆ loadFrozenGraphIntoNewSession()

◆ loadGraphIntoSession()

◆ loadSavedModel()

◆ loadSavedModelIntoNewSession()

◆ makeSessionOptions()