This is an abstract class.

#include <session.h>

A Session instance lets a caller drive a TensorFlow graph computation.


When a Session is created with a given target, a new Session object is bound to the universe of resources specified by that target. Those resources are available to this session to perform computation described in the GraphDef. After extending the session with a graph, the caller uses the Run() API to perform the computation and potentially fetch outputs as Tensors.



tensorflow::GraphDef graph;
// ... Create or load graph into "graph".

// This example uses the default options which connects
// to a local runtime.
tensorflow::SessionOptions options;

// Create the session with this graph.
tensorflow::Status s = session->Create(graph);
if (!s.ok()) { ... }

// Run the graph and fetch the first output of the "output"
// operation, and also run to but do not return anything
// for the "update_state" operation.
std::vector outputs;
s = session->Run({}, {"output:0"}, {"update_state"}, &outputs);
if (!s.ok()) { ... }

// Map the output as a flattened float tensor, and do something
// with it.
auto output_tensor = outputs[0].flat();
if (output_tensor(0) > 0.5) { ... }

// Close the session to release the resources associated with
// this session.


A Session allows concurrent calls to Run(), though a Session must be created / extended by a single thread.

Only one thread must call Close(), and Close() must only be called after all other calls to Run() have returned.

Constructors and Destructors


Public functions

Close(const RunOptions & run_options)
virtual Status
virtual Status
Closes this session.
Create(const GraphDef & graph)=0
virtual Status
Create the graph to be used for the session.
Create(const RunOptions & run_options, const GraphDef & graph)
virtual Status
Implementations which support RunOptions.
Extend(const GraphDef & graph)=0
virtual Status
Adds operations to the graph that is already registered with the Session.
Extend(const RunOptions & run_options, const GraphDef & graph)
virtual Status
PRun(const string & handle, const std::vector< std::pair< string, Tensor > > & inputs, const std::vector< string > & output_names, std::vector< Tensor > *outputs)
virtual Status
Continues the pending execution specified by handle with the provided input tensors and fills outputs for the endpoints specified in output_names.
PRunSetup(const std::vector< string > & input_names, const std::vector< string > & output_names, const std::vector< string > & target_nodes, string *handle)
virtual Status
Sets up a graph for partial execution.
Run(const std::vector< std::pair< string, Tensor > > & inputs, const std::vector< string > & output_tensor_names, const std::vector< string > & target_node_names, std::vector< Tensor > *outputs)=0