tensorflow::Scope

A Scope object represents a set of related TensorFlow ops that have the same properties such as a common name prefix.

Summary

A Scope object is a container for TensorFlow Op properties. Op constructors get a Scope object as a mandatory first argument and the constructed op acquires the properties in the object.

A simple example:

using namespace ops;
Scope root = Scope::NewRootScope();
auto c1 = Const(root, { {1, 1} });
auto m = MatMul(root, c1, { {41}, {1} });
GraphDef gdef;
Status s = root.ToGraphDef(&gdef);
if (!s.ok()) { ... }

Scope hierarchy:

The Scope class provides various With<> functions that create a new scope. The new scope typically has one property changed while other properties are inherited from the parent scope. NewSubScope(name) method appends name to the prefix of names for ops created within the scope, and WithOpName() changes the suffix which otherwise defaults to the type of the op.

Name examples:

Scope root = Scope::NewRootScope();
Scope linear = root.NewSubScope("linear");
// W will be named "linear/W"
auto W = Variable(linear.WithOpName("W"),
                  {2, 2}, DT_FLOAT);
// b will be named "linear/b"
auto b = Variable(linear.WithOpName("b"),
                  {2}, DT_FLOAT);
auto x = Const(linear, {...});  // name: "linear/Const"
auto m = MatMul(linear, x, W);  // name: "linear/MatMul"
auto r = BiasAdd(linear, m, b); // name: "linear/BiasAdd"

Scope lifetime:

A new scope is created by calling Scope::NewRootScope. This creates some resources that are shared by all the child scopes that inherit from this scope, directly or transitively. For instance, a new scope creates a new Graph object to which operations are added when the new scope or its children are used by an Op constructor. The new scope also has a Status object which will be used to indicate errors by Op-constructor functions called on any child scope. The Op-constructor functions have to check the scope's status by calling the ok() method before proceeding to construct the op.

Thread safety:

A Scope object is NOT thread-safe. Threads cannot concurrently call op-constructor functions on the same Scope object.

Public functions

Scope ClearColocation() const 

Scope ColocateWith(
  const Operation & op
) const 

Scope ColocateWith(
  const Output & out
) const 

Status DoShapeInference(
  Node *node
) const 

Scope ExitOnError() const 

CompositeOpScopes GetCompositeOpScopes(
  const string & composite_op_name
) const 

string GetUniqueNameForOp(
  const string & default_name
) const 

Scope NewSubScope(
  const string & child_scope_name
) const 

 Scope(
  const Scope & other
)

Status ToGraph(
  Graph *g
) const 

Status ToGraphDef(
  GraphDef *gdef
) const 

void UpdateBuilder(
  NodeBuilder *builder
) const 

void UpdateStatus(
  const Status s
) const 

Scope WithControlDependencies(
  const gtl::ArraySlice< Operation > & control_deps
) const 

Scope WithControlDependencies(
  const Output & control_dep
) const 

Scope WithDevice(
  const string & device
) const 

Scope WithKernelLabel(
  const string & kernel_label
) const 

Scope WithNoControlDependencies() const 

Scope WithOpName(
  const string & op_name
) const 

const std::vector< Operation > & control_deps() const 

Graph * graph() const 

std::shared_ptr< Graph > graph_as_shared_ptr() const 

Impl * impl()

const Impl * impl() const 

bool ok() const 

Scope & operator=(
  const Scope & other
)

Status status() const 

 ~Scope()

Scope DisabledShapeInferenceScope()

Scope NewRootScope()