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

#include <model.h>

Public Member Functions
	Model ()
	Creates an uninitialized model.

	Model (const std::string &model_path, const bool warmup=false, const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Creates a model by loading it from disk.

void	loadModel (const std::string &model_path, const bool warmup=false, const bool allow_growth=true, const double per_process_gpu_memory_fraction=0, const std::string &visible_device_list="")
	Loads a SavedModel or FrozenGraph model from disk.

bool	isLoaded () const
	Checks whether the model is loaded already.

std::unordered_map< std::string, tf::Tensor >	operator() (const std::vector< std::pair< std::string, tf::Tensor > > &inputs, const std::vector< std::string > &output_names) const
	Runs the model.

tf::Tensor	operator() (const tf::Tensor &input_tensor) const
	Runs the model.

std::vector< tf::Tensor >	operator() (const std::vector< tf::Tensor > &input_tensors) const
	Runs the model.

std::vector< int >	getNodeShape (const std::string &name)
	Determines the shape of a model node.

std::vector< int >	getInputShape ()
	Determines the shape of the model input.

std::vector< int >	getOutputShape ()
	Determines the shape of the model output.

std::vector< std::vector< int > >	getInputShapes ()
	Determines the shape of the model inputs.

std::vector< std::vector< int > >	getOutputShapes ()
	Determines the shape of the model outputs.

tf::DataType	getNodeType (const std::string &name)
	Determines the datatype of a model node.

tf::DataType	getInputType ()
	Determines the datatype of the model input.

tf::DataType	getOutputType ()
	Determines the datatype of the model output.

std::vector< tf::DataType >	getInputTypes ()
	Determines the datatype of the model inputs.

std::vector< tf::DataType >	getOutputTypes ()
	Determines the datatype of the model outputs.

std::string	getInfoString ()
	Returns information about the model.

tf::Session *	session () const
	Returns the underlying TensorFlow session.

const tf::SavedModelBundleLite &	savedModel () const
	Returns the underlying SavedModel.

const tf::GraphDef &	frozenGraph () const
	Returns the underlying FrozenGraph GraphDef.

bool	isSavedModel () const
	Returns whether loaded model is from SavedModel.

bool	isFrozenGraph () const
	Returns whether loaded model is from FrozenGraph.

int	nInputs () const
	Returns number of model inputs.

int	nOutputs () const
	Returns number of model outputs.

std::vector< std::string >	inputNames () const
	Returns names of model inputs.

std::vector< std::string >	outputNames () const
	Returns names of model outputs.

Protected Member Functions
void	dummyCall ()
	Runs the model once with dummy input to speed-up first inference.

Protected Attributes
tf::Session *	session_ = nullptr
	underlying TensorFlow session

tf::SavedModelBundleLite	saved_model_
	underlying SavedModel

tf::GraphDef	graph_def_
	underlying FrozenGraph GraphDef

bool	is_saved_model_ = false
	whether loaded model is from SavedModel

bool	is_frozen_graph_ = false
	whether loaded model is from FrozenGraph

int	n_inputs_
	number of model inputs

int	n_outputs_
	number of model outputs

std::vector< std::string >	input_names_
	(layer) names of model inputs

std::vector< std::string >	output_names_
	(layer) names of model outputs

std::unordered_map< std::string, std::string >	saved_model_node2layer_
	mapping between SavedModel node and layer input/output names

std::unordered_map< std::string, std::string >	saved_model_layer2node_
	mapping between SavedModel layer and node input/output names

Detailed Description

Wrapper class for running TensorFlow SavedModels or FrozenGraphs.

Definition at line 51 of file model.h.

Constructor & Destructor Documentation

◆ Model() [1/2]

tensorflow_cpp::Model::Model ( )

inline

Creates an uninitialized model.

Definition at line 57 of file model.h.

57{}

◆ Model() [2/2]

tensorflow_cpp::Model::Model	(	const std::string &	model_path,
		const bool	warmup = false,
		const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Creates a model by loading it from disk.

Parameters

[in]	model_path	SavedModel or FrozenGraph path
[in]	warmup	run dummy inference to warmup
[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"

Definition at line 69 of file model.h.

                                                   {
 
    loadModel(model_path, warmup, allow_growth, per_process_gpu_memory_fraction,
              visible_device_list);
  }

Member Function Documentation

◆ dummyCall()

void tensorflow_cpp::Model::dummyCall ( )

inlineprotected

Runs the model once with dummy input to speed-up first inference.

Definition at line 537 of file model.h.

                   {
 
    // infer input shapes/types to create dummy input tensors
    auto input_shapes = getInputShapes();
    auto input_types = getInputTypes();
    std::vector<tf::Tensor> input_dummies;
    for (int k = 0; k < n_inputs_; k++) {
      std::vector<long int> dummy_shape(input_shapes[k].begin(),
                                        input_shapes[k].end());
      // Replace -1 (batch size dimension, None in python) with 1
      std::replace(dummy_shape.begin(), dummy_shape.end(), -1l, 1l);
      auto dummy_tensor_shape =
        tf::TensorShape(tf::gtl::ArraySlice<long int>(dummy_shape));
      tf::Tensor dummy(input_types[k], dummy_tensor_shape);
      // init to zero, based on type
      switch (input_types[k]) {
        case tf::DT_FLOAT:
          dummy.flat<float>().setZero();
          break;
        case tf::DT_DOUBLE:
          dummy.flat<double>().setZero();
        case tf::DT_INT32:
          dummy.flat<tf::int32>().setZero();
          break;
        case tf::DT_UINT32:
          dummy.flat<tf::uint32>().setZero();
          break;
        case tf::DT_UINT8:
          dummy.flat<tf::uint8>().setZero();
          break;
        case tf::DT_UINT16:
          dummy.flat<tf::uint16>().setZero();
          break;
        case tf::DT_INT16:
          dummy.flat<tf::int16>().setZero();
          break;
        case tf::DT_INT8:
          dummy.flat<tf::int8>().setZero();
          break;
        case tf::DT_STRING:
          dummy.flat<tf::tstring>().setZero();
          break;
        case tf::DT_COMPLEX64:
          dummy.flat<tf::complex64>().setZero();
          break;
        case tf::DT_COMPLEX128:
          dummy.flat<tf::complex128>().setZero();
          break;
        case tf::DT_INT64:
          dummy.flat<tf::int64>().setZero();
          break;
        case tf::DT_UINT64:
          dummy.flat<tf::uint64>().setZero();
          break;
        case tf::DT_BOOL:
          dummy.flat<bool>().setZero();
          break;
        case tf::DT_QINT8:
          dummy.flat<tf::qint8>().setZero();
          break;
        case tf::DT_QUINT8:
          dummy.flat<tf::quint8>().setZero();
          break;
        case tf::DT_QUINT16:
          dummy.flat<tf::quint16>().setZero();
          break;
        case tf::DT_QINT16:
          dummy.flat<tf::qint16>().setZero();
          break;
        case tf::DT_QINT32:
          dummy.flat<tf::qint32>().setZero();
          break;
        case tf::DT_BFLOAT16:
          dummy.flat<tf::bfloat16>().setZero();
          break;
        case tf::DT_HALF:
          dummy.flat<Eigen::half>().setZero();
          break;
      }
      input_dummies.push_back(dummy);
    }
 
    // run dummy inference
    volatile auto output_dummies = (*this)(input_dummies);
  }

◆ frozenGraph()

const tf::GraphDef & tensorflow_cpp::Model::frozenGraph ( ) const

inline

Returns the underlying FrozenGraph GraphDef.

Returns: const tf::GraphDef& FrozenGraph GraphDef

Definition at line 473 of file model.h.

                                        {
    return graph_def_;
  }

◆ getInfoString()

std::string tensorflow_cpp::Model::getInfoString ( )

inline

Returns information about the model.

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

Returns: std::string formatted info message

Definition at line 439 of file model.h.

                            {
 
    if (is_saved_model_) {
      return getSavedModelInfoString(saved_model_);
    } else if (is_frozen_graph_) {
      return getGraphInfoString(graph_def_);
    } else {
      return "";
    }
  }

◆ getInputShape()

std::vector< int > tensorflow_cpp::Model::getInputShape ( )

inline

Determines the shape of the model input.

This function works without having to specify input/output names of the model, but is limited to single-input/single-output models.

Returns: std::vector<int> node shape

Definition at line 289 of file model.h.

                                 {
 
    if (n_inputs_ != 1) {
      throw std::runtime_error(
        "std::vector<int> tensorflow_cpp::Model::getInputShape()' is only "
        "available for single-input models. Found " +
        std::to_string(n_inputs_) + " inputs.");
    }
 
    return getNodeShape(input_names_[0]);
  }

◆ getInputShapes()

std::vector< std::vector< int > > tensorflow_cpp::Model::getInputShapes ( )

inline

Determines the shape of the model inputs.

Returns: std::vector<std::vector<int>> node shapes

Definition at line 326 of file model.h.

                                             {
 
    std::vector<std::vector<int>> shapes;
    for (const auto& name : input_names_) shapes.push_back(getNodeShape(name));
 
    return shapes;
  }

◆ getInputType()

tf::DataType tensorflow_cpp::Model::getInputType ( )

inline

Determines the datatype of the model input.

This function works without having to specify input/output names of the model, but is limited to single-input/single-output models.

Returns: tf::DataType node datatype

Definition at line 373 of file model.h.

                            {
 
    if (n_inputs_ != 1) {
      throw std::runtime_error(
        "'tf::DataType tensorflow_cpp::Model::getInputType()' is only "
        "available for single-input models. Found " +
        std::to_string(n_inputs_) + " inputs.");
    }
 
    return getNodeType(input_names_[0]);
  }

◆ getInputTypes()

std::vector< tf::DataType > tensorflow_cpp::Model::getInputTypes ( )

inline

Determines the datatype of the model inputs.

Returns: std::vector<tf::DataType> node datatypes

Definition at line 410 of file model.h.

                                        {
 
    std::vector<tf::DataType> types;
    for (const auto& name : input_names_) types.push_back(getNodeType(name));
 
    return types;
  }

◆ getNodeShape()

std::vector< int > tensorflow_cpp::Model::getNodeShape ( const std::string & name )

inline

Determines the shape of a model node.

Parameters

[in] name node name

Returns: std::vector<int> node shape

Definition at line 269 of file model.h.

                                                     {
 
    if (is_saved_model_) {
      return getSavedModelNodeShape(saved_model_,
                                    saved_model_layer2node_[name]);
    } else if (is_frozen_graph_) {
      return getGraphNodeShape(graph_def_, name);
    } else {
      return {};
    }
  }

◆ getNodeType()

tf::DataType tensorflow_cpp::Model::getNodeType ( const std::string & name )

inline

Determines the datatype of a model node.

Parameters

[in] name node name

Returns: tf::DataType node datatype

Definition at line 354 of file model.h.

                                                {
 
    if (is_saved_model_) {
      return getSavedModelNodeType(saved_model_, saved_model_layer2node_[name]);
    } else if (is_frozen_graph_) {
      return getGraphNodeType(graph_def_, name);
    } else {
      return tf::DataType();
    }
  }

◆ getOutputShape()

std::vector< int > tensorflow_cpp::Model::getOutputShape ( )

inline

Determines the shape of the model output.

This function works without having to specify input/output names of the model, but is limited to single-input/single-output models.

Returns: std::vector<int> node shape

Definition at line 309 of file model.h.

                                  {
 
    if (n_outputs_ != 1) {
      throw std::runtime_error(
        "std::vector<int> tensorflow_cpp::Model::getOutputShape()' is only "
        "available for single-output models. Found " +
        std::to_string(n_outputs_) + " outputs.");
    }
 
    return getNodeShape(output_names_[0]);
  }

◆ getOutputShapes()

std::vector< std::vector< int > > tensorflow_cpp::Model::getOutputShapes ( )

inline

Determines the shape of the model outputs.

Returns: std::vector<std::vector<int>> node shapes

Definition at line 339 of file model.h.

                                              {
 
    std::vector<std::vector<int>> shapes;
    for (const auto& name : output_names_) shapes.push_back(getNodeShape(name));
 
    return shapes;
  }

◆ getOutputType()

tf::DataType tensorflow_cpp::Model::getOutputType ( )

inline

Determines the datatype of the model output.

This function works without having to specify input/output names of the model, but is limited to single-input/single-output models.

Returns: tf::DataType node datatype

Definition at line 393 of file model.h.

                             {
 
    if (n_outputs_ != 1) {
      throw std::runtime_error(
        "'tf::DataType tensorflow_cpp::Model::getOutputType()' is only "
        "available for single-output models. Found " +
        std::to_string(n_outputs_) + " outputs.");
    }
 
    return getNodeType(output_names_[0]);
  }

◆ getOutputTypes()

std::vector< tf::DataType > tensorflow_cpp::Model::getOutputTypes ( )

inline

Determines the datatype of the model outputs.

Returns: std::vector<tf::DataType> node datatypes

Definition at line 423 of file model.h.

                                         {
 
    std::vector<tf::DataType> types;
    for (const auto& name : output_names_) types.push_back(getNodeType(name));
 
    return types;
  }

◆ inputNames()

std::vector< std::string > tensorflow_cpp::Model::inputNames ( ) const

inline

Returns names of model inputs.

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

Definition at line 520 of file model.h.

                                          {
    return input_names_;
  }

◆ isFrozenGraph()

bool tensorflow_cpp::Model::isFrozenGraph ( ) const

inline

Returns whether loaded model is from FrozenGraph.

Returns: true if loaded from FrozenGraph; false if not loaded from FrozenGraph

Definition at line 493 of file model.h.

                             {
    return is_frozen_graph_;
  }

◆ isLoaded()

bool tensorflow_cpp::Model::isLoaded ( ) const

inline

Checks whether the model is loaded already.

Returns: true if model is loaded; false if model is not loaded

Definition at line 143 of file model.h.

                        {
 
    bool is_loaded = bool(session_);
 
    return is_loaded;
  }

◆ isSavedModel()

bool tensorflow_cpp::Model::isSavedModel ( ) const

inline

Returns whether loaded model is from SavedModel.

Returns: true if loaded from SavedModel; false if not loaded from SavedModel

Definition at line 483 of file model.h.

                            {
    return is_saved_model_;
  }

◆ loadModel()

void tensorflow_cpp::Model::loadModel	(	const std::string &	model_path,
		const bool	warmup = false,
		const bool	allow_growth = true,
		const double	per_process_gpu_memory_fraction = 0,
		const std::string &	visible_device_list = "" )

inline

Loads a SavedModel or FrozenGraph model from disk.

After the model has loaded, it's also run once with dummy inputs in order to speed-up the first actual inference call.

Parameters

[in]	model_path	SavedModel or FrozenGraph path
[in]	warmup	run dummy inference to warmup
[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"

Definition at line 91 of file model.h.

                                                            {
 
    is_frozen_graph_ = (model_path.substr(model_path.size() - 3) == ".pb");
    is_saved_model_ = !is_frozen_graph_;
 
    // load model
    if (is_frozen_graph_) {
      graph_def_ = loadFrozenGraph(model_path);
      session_ = createSession(allow_growth, per_process_gpu_memory_fraction,
                               visible_device_list);
      loadGraphIntoSession(session_, graph_def_);
    } else {
      saved_model_ =
        loadSavedModel(model_path, allow_growth,
                       per_process_gpu_memory_fraction, visible_device_list);
      session_ = saved_model_.GetSession();
    }
 
    // automatically find inputs and outputs
    if (is_frozen_graph_) {
      input_names_ = getGraphInputNames(graph_def_);
      output_names_ = getGraphOutputNames(graph_def_);
    } else {
      input_names_ = getSavedModelInputNames(saved_model_, true);
      output_names_ = getSavedModelOutputNames(saved_model_, true);
      const auto input_nodes_ = getSavedModelInputNames(saved_model_, false);
      const auto output_nodes_ = getSavedModelOutputNames(saved_model_, false);
      for (int k = 0; k < input_names_.size(); k++) {
        saved_model_node2layer_[input_nodes_[k]] = input_names_[k];
        saved_model_layer2node_[input_names_[k]] = input_nodes_[k];
      }
      for (int k = 0; k < output_names_.size(); k++) {
        saved_model_node2layer_[output_nodes_[k]] = output_names_[k];
        saved_model_layer2node_[output_names_[k]] = output_nodes_[k];
      }
    }
    n_inputs_ = input_names_.size();
    n_outputs_ = output_names_.size();
 
    // run dummy inference to warm-up
    if (warmup) dummyCall();
  }

◆ nInputs()

int tensorflow_cpp::Model::nInputs ( ) const

inline

Returns number of model inputs.

Returns: int number of inputs

Definition at line 502 of file model.h.

                      {
    return n_inputs_;
  }

◆ nOutputs()

int tensorflow_cpp::Model::nOutputs ( ) const

inline

Returns number of model outputs.

Returns: int number of outputs

Definition at line 511 of file model.h.

                       {
    return n_outputs_;
  }

◆ operator()() [1/3]

std::unordered_map< std::string, tf::Tensor > tensorflow_cpp::Model::operator()	(	const std::vector< std::pair< std::string, tf::Tensor > > &	inputs,
		const std::vector< std::string > &	output_names ) const

inline

Runs the model.

The input/output names are expected to be set to the model layer names given during model construction. Information about the model can be printed using getInfoString. For FrozenGraphs, layer names are unknown and node names are expected.

Parameters

[in]	inputs	inputs by name
[in]	output_names	output names

Returns: std::unordered_map<std::string, tf::Tensor> outputs by name

Definition at line 163 of file model.h.

                                                   {
 
    // properly set input/output names for session->Run()
    std::vector<std::pair<std::string, tf::Tensor>> input_nodes;
    std::vector<std::string> output_node_names;
    if (is_saved_model_) {
      for (const auto& input : inputs)
        input_nodes.push_back(
          {saved_model_layer2node_.find(input.first)->second, input.second});
      for (const auto& name : output_names)
        output_node_names.push_back(saved_model_layer2node_.find(name)->second);
    } else if (is_frozen_graph_) {
      input_nodes = inputs;
      output_node_names = output_names;
    } else {
      return {};
    }
 
    // run model
    tf::Status status;
    std::vector<tf::Tensor> output_tensors;
    status = session_->Run(input_nodes, output_node_names, {}, &output_tensors);
 
    // build outputs
    std::unordered_map<std::string, tf::Tensor> outputs;
    if (status.ok()) {
      for (int k = 0; k < output_tensors.size(); k++)
        outputs[output_names[k]] = output_tensors[k];
    } else {
      throw std::runtime_error("Failed to run model: " + status.ToString());
    }
 
    return outputs;
  }

◆ operator()() [2/3]

std::vector< tf::Tensor > tensorflow_cpp::Model::operator() ( const std::vector< tf::Tensor > & input_tensors ) const

inline

Runs the model.

This version of operator() works without having to specify input/output names of the model, but is limited to FrozenGraph models.

Parameters

[in] input_tensors input tensors

Returns: std::vector<tf::Tensor> output tensors

Definition at line 237 of file model.h.

                                                    {
 
    if (input_tensors.size() != n_inputs_) {
      throw std::runtime_error(
        "Model has " + std::to_string(n_inputs_) + " inputs, but " +
        std::to_string(input_tensors.size()) + " input tensors were given");
    }
 
    // assign inputs in default order
    std::vector<std::pair<std::string, tf::Tensor>> inputs;
    for (int k = 0; k < n_inputs_; k++)
      inputs.push_back({input_names_[k], input_tensors[k]});
 
    // run model
    auto outputs = (*this)(inputs, output_names_);
 
    // return output tensors in default order
    std::vector<tf::Tensor> output_tensors;
    for (const auto& name : output_names_)
      output_tensors.push_back(outputs[name]);
 
    return output_tensors;
  }

◆ operator()() [3/3]

tf::Tensor tensorflow_cpp::Model::operator() ( const tf::Tensor & input_tensor ) const

inline

Runs the model.

This version of operator() works without having to specify input/output names of the model, but is limited to single-input/single-output models.

Parameters

[in] input_tensor input tensor

Returns: tf::Tensor output tensor

Definition at line 210 of file model.h.

                                                          {
 
    if (n_inputs_ != 1 || n_outputs_ != 1) {
      throw std::runtime_error(
        "'tf::Tensor tensorflow_cpp::Model::operator()(const tf::Tensor&)' is "
        "only available for single-input/single-output models. Found " +
        std::to_string(n_inputs_) + " inputs and " +
        std::to_string(n_outputs_) + " outputs.");
    }
 
    // run model
    auto outputs =
      (*this)({{input_names_[0], input_tensor}}, {output_names_[0]});
 
    return outputs[output_names_[0]];
  }

◆ outputNames()

std::vector< std::string > tensorflow_cpp::Model::outputNames ( ) const

inline

Returns names of model outputs.

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

Definition at line 529 of file model.h.

                                           {
    return output_names_;
  }

◆ savedModel()

const tf::SavedModelBundleLite & tensorflow_cpp::Model::savedModel ( ) const

inline

Returns the underlying SavedModel.

Returns: const tf::SavedModelBundleLite& SavedModel

Definition at line 464 of file model.h.

                                                   {
    return saved_model_;
  }

◆ session()

tf::Session * tensorflow_cpp::Model::session ( ) const

inline

Returns the underlying TensorFlow session.

Returns: tf::Session* session

Definition at line 455 of file model.h.

                             {
    return session_;
  }

Member Data Documentation

◆ graph_def_

tf::GraphDef tensorflow_cpp::Model::graph_def_

protected

underlying FrozenGraph GraphDef

Definition at line 637 of file model.h.

◆ input_names_

std::vector<std::string> tensorflow_cpp::Model::input_names_

protected

(layer) names of model inputs

Definition at line 662 of file model.h.

◆ is_frozen_graph_

bool tensorflow_cpp::Model::is_frozen_graph_ = false

protected

whether loaded model is from FrozenGraph

Definition at line 647 of file model.h.

◆ is_saved_model_

bool tensorflow_cpp::Model::is_saved_model_ = false

protected

whether loaded model is from SavedModel

Definition at line 642 of file model.h.

◆ n_inputs_

int tensorflow_cpp::Model::n_inputs_

protected

number of model inputs

Definition at line 652 of file model.h.

◆ n_outputs_

int tensorflow_cpp::Model::n_outputs_

protected

number of model outputs

Definition at line 657 of file model.h.

◆ output_names_

std::vector<std::string> tensorflow_cpp::Model::output_names_

protected

(layer) names of model outputs

Definition at line 667 of file model.h.

◆ saved_model_

tf::SavedModelBundleLite tensorflow_cpp::Model::saved_model_

protected

underlying SavedModel

Definition at line 632 of file model.h.

◆ saved_model_layer2node_

std::unordered_map<std::string, std::string> tensorflow_cpp::Model::saved_model_layer2node_

protected

mapping between SavedModel layer and node input/output names

Definition at line 677 of file model.h.

◆ saved_model_node2layer_

std::unordered_map<std::string, std::string> tensorflow_cpp::Model::saved_model_node2layer_

protected

mapping between SavedModel node and layer input/output names

Definition at line 672 of file model.h.

◆ session_

tf::Session* tensorflow_cpp::Model::session_ = nullptr

protected

underlying TensorFlow session

Definition at line 627 of file model.h.

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

/github/workspace/include/tensorflow_cpp/model.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Model() [1/2]

◆ Model() [2/2]

Member Function Documentation

◆ dummyCall()

◆ frozenGraph()

◆ getInfoString()

◆ getInputShape()

◆ getInputShapes()

◆ getInputType()

◆ getInputTypes()

◆ getNodeShape()

◆ getNodeType()

◆ getOutputShape()

◆ getOutputShapes()

◆ getOutputType()

◆ getOutputTypes()

◆ inputNames()

◆ isFrozenGraph()

◆ isLoaded()

◆ isSavedModel()

◆ loadModel()

◆ nInputs()

◆ nOutputs()

◆ operator()() [1/3]

◆ operator()() [2/3]

◆ operator()() [3/3]

◆ outputNames()

◆ savedModel()

◆ session()

Member Data Documentation

◆ graph_def_

◆ input_names_

◆ is_frozen_graph_

◆ is_saved_model_

◆ n_inputs_

◆ n_outputs_

◆ output_names_

◆ saved_model_

◆ saved_model_layer2node_

◆ saved_model_node2layer_

◆ session_